resme 1.0.1 → 2.0.1

data/lib/resme/document_validator.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Resme
+  #
+  # Validate a document
+  #
+  class DocumentValidator
+    def initialize(document)
+      @document = document
+    end
+
+    def validate
+      errors = []
+      ClassyHash.validate(
+        @document.data,
+        SCHEMA,
+        errors: errors,
+        strict: true,
+        raise_errors: true,
+        full: true
+      )
+      errors
+    rescue StandardError => e
+      puts "#{@document.filename} does not validate:"
+      e.entries.each do |error|
+        puts "- #{error[:full_path]}: #{error[:message]}"
+      end
+    end
+
+    OPTIONAL_STRING = [:optional, String, NilClass].freeze
+    OPTIONAL_PARTIAL_DATE = [:optional, Date, String, Integer, NilClass].freeze
+    PARTIAL_DATE = [Date, String, Integer].freeze
+
+    #
+    # This defines the structure of resume.yml
+    # We validate it with ClassyHash
+    #
+    SCHEMA = {
+      basics: {
+        first_name: String,
+        middle_name: OPTIONAL_STRING,
+        last_name: String,
+        title: OPTIONAL_STRING,
+        picture: OPTIONAL_STRING,
+        birthdate: [:optional, Date, NilClass],
+        nationality: OPTIONAL_STRING,
+        marital_status: OPTIONAL_STRING,
+        gender: OPTIONAL_STRING
+      },
+      contacts: [[{ label: String, value: String }]],
+      addresses: [[{
+                     label: String,
+                     street: OPTIONAL_STRING,
+                     postal_code: [:optional, String, Integer, NilClass],
+                     city: OPTIONAL_STRING,
+                     region: OPTIONAL_STRING,
+                     country_code: OPTIONAL_STRING,
+                     country: OPTIONAL_STRING
+                   }]],
+      web_presence: [:optional,
+                     [[{ label: String, value: String }]],
+                     NilClass
+                    ],
+      summary: OPTIONAL_STRING,
+      work: [:optional,
+             [[{
+                 name: OPTIONAL_STRING,
+                 url: OPTIONAL_STRING,
+                 address: OPTIONAL_STRING,
+                 end_date: OPTIONAL_PARTIAL_DATE,
+                 start_date: OPTIONAL_PARTIAL_DATE,
+                 position: String,
+                 summary: String,
+                 details: OPTIONAL_STRING
+               }]],
+             NilClass
+            ],
+      teaching: [:optional,
+                 [[{
+                     name: String,
+                     school: OPTIONAL_STRING,
+                     address: OPTIONAL_STRING,
+                     end_date: OPTIONAL_PARTIAL_DATE,
+                     start_date: OPTIONAL_PARTIAL_DATE,
+                     position: String,
+                     subject: String,
+                     summary: OPTIONAL_STRING,
+                     details: OPTIONAL_STRING
+                   }]],
+                 NilClass
+                ],
+      projects: [:optional,
+                 [[{
+                     name: String,
+                     size: OPTIONAL_STRING,
+                     stakeholder: OPTIONAL_STRING,
+                     end_date: OPTIONAL_PARTIAL_DATE,
+                     start_date: OPTIONAL_PARTIAL_DATE,
+                     position: String,
+                     summary: OPTIONAL_STRING
+                   }]],
+                 NilClass
+                ],
+      other: [:optional,
+              [[{
+                  name: OPTIONAL_STRING,
+                  end_date: OPTIONAL_PARTIAL_DATE,
+                  start_date: OPTIONAL_PARTIAL_DATE,
+                  position: String,
+                  summary: OPTIONAL_STRING
+                }]],
+              NilClass
+             ],
+      committees: [:optional,
+                   [[{
+                       name: String,
+                       position: String,
+                       editions: [String, Integer],
+                       url: OPTIONAL_STRING
+                     }]],
+                   NilClass
+                  ],
+      volunteer: [:optional,
+                  [[{
+                      name: String,
+                      where: OPTIONAL_STRING,
+                      date: OPTIONAL_PARTIAL_DATE,
+                      end_date: OPTIONAL_PARTIAL_DATE,
+                      start_date: OPTIONAL_PARTIAL_DATE,
+                      position: String,
+                      summary: OPTIONAL_STRING
+                    }]],
+                  NilClass
+                 ],
+      visits: [:optional,
+               [[{
+                   name: String,
+                   address: OPTIONAL_STRING,
+                   end_date: OPTIONAL_PARTIAL_DATE,
+                   start_date: OPTIONAL_PARTIAL_DATE,
+                   position: String,
+                   summary: OPTIONAL_STRING
+                 }]],
+               NilClass
+              ],
+      education: [:optional,
+                  [[{
+                      degree: OPTIONAL_STRING,
+                      topic: OPTIONAL_STRING,
+                      school: String,
+                      address: OPTIONAL_STRING,
+                      date: OPTIONAL_PARTIAL_DATE,
+                      end_date: OPTIONAL_PARTIAL_DATE,
+                      start_date: OPTIONAL_PARTIAL_DATE,
+                      url: OPTIONAL_STRING,
+                      publish: TrueClass,
+                      score: [:optional, String, Integer, NilClass]
+                    }]],
+                  NilClass
+                 ],
+      publications: [:optional,
+                     [[{
+                         title: String,
+                         authors: String,
+                         publisher: String,
+                         date: PARTIAL_DATE,
+                         url: OPTIONAL_STRING
+                       }]],
+                     NilClass
+                    ],
+      talks: [:optional,
+              [[{
+                  title: String,
+                  venue: String,
+                  date: PARTIAL_DATE,
+                  url: OPTIONAL_STRING
+                }]],
+              NilClass
+             ],
+      awards: [:optional,
+               [[{
+                   name: String,
+                   address: OPTIONAL_STRING,
+                   date: PARTIAL_DATE,
+                   title: String,
+                   summary: OPTIONAL_STRING
+                 }]],
+               NilClass
+              ],
+      achievements: [:optional,
+                     [[{
+                         name: String,
+                         address: OPTIONAL_STRING,
+                         date: OPTIONAL_PARTIAL_DATE,
+                         title: String,
+                         summary: OPTIONAL_STRING
+                       }]],
+                     NilClass
+                    ],
+      software: [:optional,
+                 [[{
+                     title: String,
+                     url: OPTIONAL_STRING,
+                     programming_language: OPTIONAL_STRING,
+                     license: OPTIONAL_STRING,
+                     position: OPTIONAL_STRING,
+                     summary: OPTIONAL_STRING
+                   }]],
+                 NilClass
+                ],
+      skills: [:optional,
+               [[{
+                   name: String,
+                   level: OPTIONAL_STRING,
+                   summary: OPTIONAL_STRING
+                 }]],
+               NilClass
+              ],
+      driving: [:optional,
+                [[{ license: String }]],
+                NilClass
+               ],
+      languages: [:optional,
+                  {
+                    mother_tongues: [[{
+                                        code: OPTIONAL_STRING,
+                                        language: String,
+                                       }
+                                     ]],
+                    foreign: [:optional,
+                              [[{
+                                  code: OPTIONAL_STRING,
+                                  language: String,
+                                  level: OPTIONAL_STRING,
+                                  listening: OPTIONAL_STRING,
+                                  reading: OPTIONAL_STRING,
+                                  spoken_interaction: OPTIONAL_STRING,
+                                  spoken_production: OPTIONAL_STRING,
+                                  writing:  OPTIONAL_STRING
+                                }]],
+                              NilClass
+                             ]
+                  },
+                  NilClass
+                 ],
+      interests: [:optional,
+                  [[{
+                      name: String,
+                      level: OPTIONAL_STRING,
+                      summary: OPTIONAL_STRING
+                    }]],
+                  NilClass
+                 ],
+      references: [:optional,
+                   [[{
+                       name: String,
+                       reference: String,
+                       contacts: [[{ label: String, value: String }]]
+                     }]],
+                   NilClass
+                  ]
+    }.freeze
+  end
+end

data/lib/resme/executor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Resme
+  #
+  # Execute!
+  # 
+  class Executor
+    # include all formatter helpers
+    include Resme::Helper
+
+    def initialize(input)
+      @input = input
+      @options = Cli.new(@input)
+      @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)
+        validator = DocumentValidator.new(document)
+        validator.validate
+
+      when :sections
+        filename = @options.options[:filename]
+        keys = Document.new(filename).data.keys
+        puts keys
+
+      when :build
+        filename = @options.options[:filename]
+        data = Document.new(filename).data
+
+        except = @options.options[:except] || []
+        @data = Document.new(filename).data.except(*except)
+
+        format = @options.options[:format]
+        template_name = File.join __dir__, "../../templates/#{format}.erb"
+        template = File.read(template_name)
+
+        # add the json format, if specified
+        if format.to_s == "json"
+          js = JsonResume.new Document.new(filename)
+          @json_resume = js.build
+        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)
+
+      when :list
+        templates = File.join __dir__, "../../templates/*.erb"
+        files = Dir.glob(templates).map { |x| "#{File.basename(x)} => #{x}" }
+        puts files.join("\n")
+
+      when :cat
+        template = @options.options[:template]
+        template_path = File.join __dir__, "../../templates/#{template}"
+        puts File.read template_path
+
+      when :help
+        # nothing to do, OptParser has the context
+
+      when :version
+        puts "This is version: #{Resme::VERSION}"
+
+      end
+    end
+    # rubocop:enable Metrics
+
+    private
+
+    def output_filename(format)
+      "resume-#{Date.today.iso8601}.#{format}"
+    end
+
+    def backup(filename)
+      FileUtils.cp "filename, "#{filename}~"
+      puts "Backup copy #{filename} created in #{filename}~."
+    end
+
+    def backup_and_write(filename, content)
+      backup(filename) if File.exist?(filename)
+      File.open(filename, "w") { |f| f.puts content }
+    end
+  end
+end

data/lib/resme/helper.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Resme
+  #
+  # Helper functions for renderers
+  #
+  module Helper
+    # Strip and replace extra spaces and special chars with a single space
+    def clean(string)
+      string.strip.gsub(/[\t\n ]+/, " ")
+    end
+
+    def full_name(data)
+      [
+        data.dig(:basics, :first_name),
+        data.dig(:basics, :middle_name),
+        data.dig(:basics, :last_name),
+      ].compact.join(" ")
+    end
+
+    # Break a string into substrings of length chars breaking at spaces
+    # and newlines
+    #
+    # - `string` string to reflow
+    # - `chars` number of characters to break the string at
+    #
+    # Returns an array of strings of length < chars (with exceptions for special
+    # cases).
+    #
+    # 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
+
+      # here the string is longer than line_break chars
+      #
+      # if the string has a space between 0 and line_break, we break the
+      # string and apply recursion
+      #
+      line_break.downto(0).each do |index|
+        if blank?(string[index])
+          return [clean(string[0..(index - 1)])] +
+                 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
+      # apply recursion
+      #
+      line_break.upto(string.length).each do |index|
+        if blank?(string[index])
+          return [clean(string[0..(index - 1)])] +
+                 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.
+    #
+    def reflow_s(string, line_break: 75, delimiter: "\n", indent: 3)
+      indentation = " " * indent
+
+      # remember PARAGRAPH BREAKS
+      paragraphs = string.gsub("\n\n", "{{PBREAK}}").split("{{PBREAK}}")
+
+      formatted_pars = paragraphs.map do |paragraph|
+        reflow_a(paragraph, line_break:).join(delimiter).gsub(/^/, indentation)
+      end
+
+      formatted_pars.join("\n\n") + "\n"
+    end
+
+    # Return a string encoding a period (start - end) from a Hash, containing
+    # the specificatio of the period.  Manage special cases (partial dates,
+    # optional dates).
+    #
+    # Entry is the input Hash, +from+ is the digging specification to get the
+    # "start" date, +to+ is the digging specification to get the "end" date.
+    # Fallback is a key we use if +from+ or +to+ are not present.
+    # All accept a Symbol or an Array.
+    #
+    # abstract dates at the year level, taking care of periods if from and
+    # till are in two different years
+    #
+    def period(entry, date: :date, from: :start_date, to: :end_date, separator: "--")
+      date = entry[date]
+
+      return format_date(date) if date.is_a?(Date)
+
+      from = entry.dig(*[from].flatten)
+      to = entry.dig(*[to].flatten)
+
+      [format_date(from), separator, format_date(to)].compact.join(" ")
+    end
+
+    # make an entry into an itemized list
+    #
+    # - +entry+ is a hash containing the specification of a position to itemize
+    #   (e.g., a work period, a degree, ...)
+    #
+    # - +header+, is an array of symbols, whose values, comma-separated will
+    #   generate the header line
+    #
+    # The output is a String along the lines of:
+    #
+    # - value of key1, value of key2
+    #   period
+    #   reflowed summary
+    #
+    def itemize(entry, header: %i[role who address], summary_key: :summary)
+      header = clean header.map { |x| entry[x] }.compact.join(", ")
+
+      %(- #{header}
+          #{period entry}
+          #{reflow_to_s entry[summary_key], line_break: 72, indent: 2}
+       ).gsub(/^          /, "")
+    end
+
+    # Make a Hash into a list of properties, optionally excluding some keys
+    # specified in +except:+ (by default +summary+ and +details+)
+    def propertify(entry, except: %i[summary details], indent: 3)
+      indentation = " " * indent
+
+      head = ":PROPERTIES:"
+      body = entry.except(*except).map { |k, v| ":#{k.upcase}: #{v}" }.join("\n")
+      tail = ":END:"
+
+      "#{head}\n#{body}\n#{tail}\n".gsub!(/^/, indentation)
+    end
+
+    def select(contacts, label: :email)
+      contact = (contacts || []).find { |x| x[:label] == label.to_s }
+      contact ? contact[:value] : nil
+    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
+    #
+    # Special case of an empty date (date == nil) returns ""
+    #
+    def format_date(date, format: "%Y-%m-%d")
+      date.is_a?(Date) ? date.strftime(format) : date.to_s
+    end
+
+    def complete_date(incomplete_date, format: "%Y-%m-%d")
+      return incomplete_date.strftime(format) if incomplete_date.is_a?(Date)
+
+      if ymd?(incomplete_date.to_s)
+        incomplete_date.to_s
+      elsif ym?(incomplete_date.to_s)
+        "#{incomplete_date}-01"
+      elsif y?(incomplete_date.to_s)
+        "#{incomplete_date}-01-01"
+      end
+    end
+
+    # Return the year
+    def year(input)
+      input.is_a?(Date) ? input.strftime("%Y") : input.to_s[0..3]
+    end
+
+    # Return the month
+    def month(input)
+      input.is_a?(Date) ? input.strftime("%m") : input.to_s[5..6]
+    end
+
+    # Return the day
+    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
+    end
+
+    # Is the input in the form YYYY-MM(-..)
+    def ym?(input)
+      input.is_a?(Date) || input.to_s.size == 7
+    end
+
+    # Is the input in the form YYYY-MM-DD
+    def ymd?(input)
+      input.is_a?(Date) || input.to_s.size == 10
+    end
+  end
+end