cv-tool 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b4ea67b5e07754ecf8e767310d84e604378ff05d32c3e2ef8084a369a3127ae
+  data.tar.gz: 72f397c82a4180513710d6c1059e537f2f7d461feea56ab7cc373e1dd6d38433
+SHA512:
+  metadata.gz: 2b814fb52649dc7fae5ea6acd9a9776822e654189fe930808a158c5b283c79de4c0e65a2646ec072c7d3f61717724fab5705ec50c5083d44d47e7fec04646dce
+  data.tar.gz: 2a2b26d733e9349b02f83de36838a89ea6c2a74e8e5cd3f148b406177aa1f7c74e1ca682f66da0b71696d011d9dad362b3eaaac3ce8fe5d69702e6c87c6beeb8

data/app/arguments.rb

@@ -0,0 +1,103 @@
+require 'option_parser'
+
+@options = {
+  rest_api: {
+    is_active: false,
+    endpoint: nil,
+    request_body: nil,
+    generate_db: nil,
+  },
+  gt_length: -1,
+  api_url: nil,
+  is_ssl: nil,
+}
+
+OptionParser.parse do |parser|
+  parser.banner(
+    "Using the REST API, this tool is used to modify the website CV.\n" +
+    "Usage: #{CVTool::Constants::APP_NAME} [options]\n" +
+    "\nOptions:"
+  )
+  parser.on( "-h", "--help", "Show help" ) do
+    puts parser
+    exit
+  end
+  parser.on( "-v", "--version", "Show version" ) do
+    CVTool::Event.print('VERSION |', CVTool::VERSION)
+    exit
+  end
+  parser.on( "-dp", "--deactive-print", "Disables the printing process." ) do
+    bool = false
+    CVTool::Event.print('PRINT', bool)
+    CVTool::Event::set_print_active(bool)
+  end
+  parser.on( "-ra", "--rest-api", "Rest API for get and post operations\n" +
+             "(additional setting options)." ) do
+    @options[:rest_api][:is_active] = true
+
+    OptionParser.parse do |parser|
+      parser.banner(
+        "Rest API for get and post operations.\n" +
+        "Usage: #{CVTool::Constants::APP_NAME} -ra [options]\n" +
+        "\nOptions:"
+      )
+      parser.on( "-h", "--help", "Show help" ) do
+        puts parser
+        exit
+      end
+      parser.on( "-ep ROUTE", "--endpoint ROUTE", "Defining an endpoint to use in order\n" +
+                 "to access a specific function." ) do |route|
+        @options[:rest_api][:endpoint] = route
+        CVTool::Event.print('ENDPOINT', route)
+      end
+      parser.on( "-epl", "--endpoints-list", "A list of endpoints is printed." ) do
+        CVTool::Event.print('ENDPOINTS', "| All endpoints are listed in a printout.\n\n")
+        puts CVTool::Constants::ENDPOINTS
+        exit
+      end
+      parser.on( "-reb PATH", "--request-body PATH", "The information that must be sent\n" +
+          "as *request.body* via a json file.\n" +
+          "(The location to the *.json* file must be\n" +
+          "entered if this option is chosen;\n" +
+          "else, the data must be manually entered\n" +
+          "via the terminal input.)" ) do |path|
+        @options[:rest_api][:request_body] = path
+        CVTool::Event.print('REQUEST-BODY', path)
+      end
+      parser.on( "-gdb PATH", "--generate-db PATH", "It creates *json* files for Projects and\n" +
+          "Articles in the defined path (it obtains\n" +
+          "the relevant data from the Rest API, which\n" +
+          "is then sorted and saved).\n" ) do |path|
+        
+        unless path
+          path = Dir.pwd
+        end
+
+        @options[:rest_api][:generate_db] = path
+        CVTool::Event.print('GENERATE-DB', path)
+      end
+    end
+  end
+  parser.on( "-gt LENG", "--generate-token LENG",
+      "To secure API server access, this function\n" +
+      "generates a token with a specified length\n" +
+      "(manual entry of the token into the ENV\n" +
+      "is required).\n" +
+      "The default: #{CVTool::Constants::GT_LENGTH} length" ) do |length|
+
+    length = length.to_i
+    if length <= 0
+      length = CVTool::Constants::GT_LENGTH
+    end
+    @options[:gt_length] = length
+  end
+  parser.on( "-sa URL", "--set-api URL", "Sets the API server's primary URL.\n" +
+      "The default: #{@configuration.parse(:api_url)}" ) do |url|
+    @options[:api_url] = url
+  end
+  parser.on( "-ss BOOL", "--set-ssl BOOL", "Sets the SSL encryption protocol.\n" +
+      "The default: #{@configuration.parse(:is_ssl)}" ) do |is_ssl|
+
+    @options[:is_ssl] = is_ssl.to_s.to_b
+  end
+end

data/app/configuration.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+@configuration = JsonParser.new File.join(ROOT, 'config/default.json')
+@configuration.on :api_url, CVTool::Constants::API_URI
+@configuration.on :is_ssl, true
+
+h_api_url = lambda do |_|
+  return @configuration.parse(:api_url)
+end
+
+h_is_ssl = lambda do |_|
+  return @configuration.parse(:is_ssl).to_b
+end
+
+def get_config_str()
+  JSON.pretty_generate(@configuration.db)
+end
+
+CVTool::Event.add(:api_url, h_api_url)
+CVTool::Event.add(:is_ssl, h_is_ssl)

data/app/inputs.rb

@@ -0,0 +1,59 @@
+h_add = lambda do |args|
+  result = {}
+  symbol = args[0]
+
+  begin
+    CVTool::Constants::SHEMAS[symbol].each do |name|
+      l_input = lambda do |info|
+        print "#{info}: "
+        input = STDIN.gets.chomp
+        return input
+      end
+
+      unless name == CVTool::Constants::SHEMAS[:project][3]
+        input = l_input.call(name) 
+        if name.index('is') or name.index('id')
+          input = input.to_i()
+        end
+        result[name.to_sym] = input
+      else
+        input = l_input.call("#{name} (a file's path)")
+        content = CVTool::Files.get_content( input )
+        result[name.to_sym] = content
+      end
+    end
+  rescue Interrupt => e
+  end
+
+  return result
+end
+
+h_free = lambda do |_|
+  result = {}
+
+  begin
+    print "id: "
+    result[:id] = STDIN.gets.chomp.to_i
+  rescue Interrupt => e
+  end
+
+  return result
+end
+
+h_update = lambda do |_|
+  result = {}
+
+  begin
+    print "id: "
+    result[:id] = STDIN.gets.chomp.to_i
+    print "query: "
+    result[:query] = STDIN.gets.chomp
+  rescue Interrupt => e
+  end
+
+  return result
+end
+
+CVTool::Event.add(:input_add, h_add)
+CVTool::Event.add(:input_free, h_free)
+CVTool::Event.add(:input_update, h_update)

data/app/main.rb

@@ -0,0 +1,95 @@
+require 'cv_tool'
+require_relative './configuration'
+require_relative './arguments'
+require_relative './inputs'
+require_relative './signals'
+
+def token_state()
+  unless @options[:gt_length] == -1
+    token = CVTool.generate_token( @options[:gt_length] )
+    CVTool::Event.print('TOKEN |', token)
+  end
+end
+
+def api_url_state()
+  sym = :api_url
+  api_url = @options[sym]
+  if api_url
+    @configuration.parse(sym, api_url)
+    CVTool::Event.print('SET', "#{sym.to_s}: #{api_url.to_s}")
+  end
+end
+
+def is_ssl_state()
+  sym = :is_ssl
+  is_ssl = @options[sym]
+  unless is_ssl == nil
+    @configuration.parse(sym, is_ssl.to_s)
+    CVTool::Event.print('SET', "#{sym.to_s}: #{is_ssl.to_s}")
+  end
+end
+
+def ra_define_method_state(endpoint, &block)
+  h_get = lambda do
+    CVTool::RestApi.get(@options[:rest_api]) do |response|
+      if block
+        block.call(response)
+      end
+    end
+  end
+  h_post = lambda do
+    CVTool::RestApi.post(@options[:rest_api]) do |response|
+      if block
+        block.call(response)
+      end
+    end
+  end
+
+  CVTool::RestApi.define_method( endpoint, h_get, h_post )
+end
+
+def rest_api_state(&block)
+  endpoint = @options[:rest_api][:endpoint]
+  unless endpoint
+    CVTool::Event.print('WARNING', "| You must fill out the Endpoint for " +
+        "the Rest API in order to manage the server.")
+    exit
+  end
+
+  ra_define_method_state(endpoint) do |response|
+    if block
+      block.call(response)
+    end
+  end
+end
+
+def generate_db_state()
+  get_endpoints = [
+    CVTool::Constants::ENDPOINTS[0],
+    CVTool::Constants::ENDPOINTS[1]
+  ]
+
+  get_endpoints.each do |endpoint|
+    @options[:rest_api][:endpoint] = endpoint
+    rest_api_state() do |response|
+      args = {
+        endpoint: endpoint,
+        response: response,
+        path: @options[:rest_api][:generate_db]
+      }
+      CVTool.generate_db(args)
+    end
+  end
+end
+
+if @options[:rest_api][:is_active]
+  unless @options[:rest_api][:generate_db]
+    rest_api_state()
+  else
+    generate_db_state()
+  end
+else
+  token_state()
+  api_url_state()
+  is_ssl_state()
+end

data/app/signals.rb

@@ -0,0 +1,5 @@
+Signal.trap("INT") do
+  puts
+  CVTool::Event.print('EXITING')
+  exit
+end

data/bin/cvtool

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+ROOT = File.expand_path("..", __dir__)
+$: << "#{ROOT}/lib"
+require_relative "#{ROOT}/app/main"

data/lib/cv_tool/constants.rb

@@ -0,0 +1,55 @@
+module CVTool
+  module Constants
+    APP_NAME = 'cvtool'
+    API_URI = 'http://localhost:8080/api/v1'
+    ENDPOINTS = [
+      'get/articles',
+      'get/projects',
+      'get/profiles',
+
+      'post/article/add',
+      'post/article/free',
+      'post/article/update',
+
+      'post/project/add',
+      'post/project/free',
+      'post/project/update',
+
+      'post/profile/add',
+      'post/profile/free',
+      'post/profile/update',
+
+      'post/tables/reset',
+    ]
+    METHODS = [
+      'get',
+      'post'
+    ]
+    SHEMAS = {
+      article: [
+        'author_id',
+        'project_id',
+        'name',
+        'description',
+        'url'
+      ],
+      project: [
+        'author_id',
+        'name',
+        'category',
+        'content'
+      ],
+      profile: [
+        'is_author',
+        'full_name',
+        'avatar',
+        'email',
+        'phone',
+        'bio',
+        'password'
+      ]
+    }
+    GT_LENGTH = 40
+    ENV_NAME = 'CV_TOKEN'
+  end
+end

data/lib/cv_tool/event.rb

@@ -0,0 +1,28 @@
+module CVTool
+  module Event
+    HANDLERS = {}
+    @is_print_active = true
+
+    module_function
+
+    def set_print_active(bool)
+      @is_print_active = bool
+    end
+
+    def print(event, message = "")
+      unless @is_print_active
+        return
+      end
+
+      puts "#{Time.now.strftime("%l:%M:%S %p").lstrip} [#{Constants::APP_NAME}] #{event} #{message}"
+    end
+
+    def add(symbol, handler)
+      HANDLERS[symbol] = handler
+    end
+
+    def emit(symbol, *args)
+      HANDLERS[symbol].call(args)
+    end
+  end
+end

data/lib/cv_tool/files.rb

@@ -0,0 +1,47 @@
+require 'uri'
+require 'json_parser'
+
+module CVTool
+  module Files
+    module_function
+
+    def open(path)
+      result = ""
+
+      if File.exist? path
+        File.open path do |f|
+          result = f.read
+        end
+      end
+
+      result
+    end
+
+    def get_content(path_or_content)
+      content = path_or_content
+      path = content.gsub('\'', '').strip
+      if File.exist? path
+        content = Files.open(path)
+      end
+
+      return URI.encode_www_form_component(content)
+    end
+
+    def json?(str)
+      result = JSON.parse(str)
+      result.is_a?(Hash) || result.is_a?(Array)
+    rescue JSON::ParserError, TypeError
+      return false
+    end
+
+    def get_json_db(path)
+      if File.exist? path
+        path = path.gsub('\'', '').strip
+        json_parser = JsonParser.new(path)
+        return json_parser.db
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/cv_tool/http.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+module CVTool
+  module Http
+    module_function
+
+    def get_status_code(response)
+      code = response.scan(/\d+/)[0]
+      status = response.sub(code, '').strip
+
+      status_code = {
+        'status_code': {
+          'code': code.to_i,
+          'status': status
+        }
+      }
+      return status_code
+    end
+  end
+end

data/lib/cv_tool/os.rb

@@ -0,0 +1,15 @@
+module CVTool
+  module OS
+    module_function
+
+    def get_token()
+      env = ENV[Constants::ENV_NAME]
+      if env == nil
+        Event.print('TOKEN', "| It needs to be inserted as a value because it does " +
+          "not receive a token from the #{Constants::ENV_NAME} environment.")
+        exit
+      end
+      return env
+    end
+  end
+end

data/lib/cv_tool/rest_api.rb

@@ -0,0 +1,163 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module CVTool
+  module RestApi
+    module_function
+
+    def get_uri(endpoint)
+      return "#{Event.emit(:api_url)}/#{ endpoint }"
+    end
+
+    def define_method(endpoint, h_get, h_post)
+      method = endpoint.sub(/\/.*$/, '')
+      
+      case method
+      when Constants::METHODS[0]
+        h_get.call()
+      when Constants::METHODS[1]
+        h_post.call()
+      end
+    end
+
+    def defined_data(endpoint, request_body)
+      result = {}
+
+      if request_body == nil
+        h_event_print = lambda do
+          Event.print('INPUT', '| The data for the following ' +
+            'process is defined by the input process.')
+        end
+        h_add = lambda do |symbol|
+          h_event_print.call()
+          result = Event::emit(:input_add, symbol)
+        end
+        h_free = lambda do
+          h_event_print.call()
+          result = Event::emit(:input_free)
+        end
+        h_update = lambda do
+          h_event_print.call()
+          result = Event::emit(:input_update)
+        end
+
+        case endpoint
+        # Articles
+        when Constants::ENDPOINTS[3]
+          h_add.call(:article)
+        when Constants::ENDPOINTS[4]
+          h_free.call()
+        when Constants::ENDPOINTS[5]
+          h_update.call()
+        # Projects
+        when Constants::ENDPOINTS[6]
+          h_add.call(:project)
+        when Constants::ENDPOINTS[7]
+          h_free.call()
+        when Constants::ENDPOINTS[8]
+          h_update.call()
+        # Profiles
+        when Constants::ENDPOINTS[9]
+          h_add.call(:profile)
+        when Constants::ENDPOINTS[10]
+          h_free.call()
+        when Constants::ENDPOINTS[11]
+          h_update.call()
+        end
+      else
+        result = Files.get_json_db(request_body)
+
+        if result == nil
+          CVTool::Event.print('ERROR', "| This '#{request_body}' " +
+            "file cannot be loaded because of an invalid path.")
+          exit
+        end
+
+        content_symbol = Constants::SHEMAS[:project][3].to_s
+        content = result[content_symbol]
+        if content
+          content = Files.get_content( content )
+          result[content_symbol] = content
+        end
+      end
+
+      return result
+    end
+
+    def get(args, &block)
+      uri_api = get_uri(args[:endpoint])
+      response = http_response(uri_api)
+
+      CVTool::Event.print('RESPONSE', "#{uri_api} #{JSON.pretty_generate(response)}")
+      if block
+        block.call(response)
+      end
+    end
+
+    def post(args, &block)
+      uri_api = get_uri(args[:endpoint])
+      data = defined_data(args[:endpoint], args[:request_body])
+      response = http_request(uri_api, data)
+
+      CVTool::Event.print('RESPONSE', "#{uri_api} #{JSON.pretty_generate(response)}")
+      if block
+        block.call(response)
+      end
+    end
+
+    def http_request(uri_api, data)
+
+      header = { 'Content-Type': 'text/json' }
+      token = OS.get_token
+      data[:token] = token
+
+      begin
+        uri = URI.parse(uri_api)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = Event.emit(:is_ssl)
+
+        request = Net::HTTP::Post.new(uri.request_uri, header)
+        request.body = data.to_json
+
+        response = http.request(request)
+        CVTool::Event.print('REQUEST', '| Server has received the request and is processing it.')
+
+        obj = if Files.json?(response.body) then JSON.parse(response.body)
+                else Http.get_status_code(response.body) end
+
+        return obj
+      rescue Errno::ECONNREFUSED => e
+        Event.print('ERROR', "| A request from the server is not " +
+          "answered by this #{uri_api} url address.")
+        exit
+      end
+    end
+
+    def http_response(uri_api)
+      begin
+        uri = URI(uri_api)
+        response = Net::HTTP.get(uri)
+        obj = if Files.json?(response) then JSON.parse(response)
+                else Http.get_status_code(response) end
+
+        return obj
+      rescue Errno::ECONNREFUSED => e
+        Event.print('ERROR', "| A request from the server is not " +
+          "answered by this #{uri_api} url address.")
+        exit
+      end
+    end
+
+    def get_route(args)
+      route = ""
+      if args[:is_get]
+        route += "get"
+      else args[:is_post]
+        route += "post"
+      end
+
+      return route
+    end
+  end
+end

data/lib/cv_tool/version.rb

@@ -0,0 +1,3 @@
+module CVTool
+  VERSION = '1.0.0'
+end

data/lib/cv_tool.rb

@@ -0,0 +1,39 @@
+require 'string'
+require 'json_parser'
+require 'cv_tool/version'
+require 'cv_tool/constants'
+require 'cv_tool/event'
+require 'cv_tool/files'
+require 'cv_tool/http'
+require 'cv_tool/os'
+require 'cv_tool/rest_api'
+
+module CVTool
+  module_function
+
+  def generate_token(length = Constants::GT_LENGTH)
+    chars = Array('A'..'Z') + Array('a'..'z') + Array(0..9)
+    token = Array.new(length) { chars.sample }.join
+    return token
+  end
+
+  def generate_db(args)
+    name_dir = args[:endpoint].sub('get/', '')
+    absolute_path_dir = File.expand_path(name_dir, args[:path])
+    contents = args[:response]
+
+    contents.each.with_index do |c, i|
+      content = c.delete_if do |k, _|
+        k == :id.to_s or k == :created_at.to_s or k == :last_change.to_s
+      end
+      name_file = "#{ name_dir.sub(/s$/, '') }_#{i + 1}.json"
+      absolute_path_file = File.join(absolute_path_dir, name_file)
+      json = JsonParser.new(absolute_path_file)
+
+      content.each do |k, v|
+        json.parse(k, v)
+      end
+      CVTool::Event.print('GENERATE', absolute_path_file)
+    end
+  end
+end

data/lib/json_parser.rb

@@ -0,0 +1,96 @@
+require "json"
+require 'fileutils'
+
+class JsonParser
+  attr_reader :path, :db
+  
+  def initialize path, auto_write = true
+    @path = path
+    @db = open @path
+    @auto_write = auto_write
+  end
+
+  def on symbol, value
+    unless @db.include?(symbol.to_s)
+      parse symbol, value
+    end
+  end
+
+  def parse symbols, value = nil, delete = nil
+    symbols_join = ""
+    if symbols.class.name == "Array"
+      symbols_join = symbols.join("\"][\"")
+    else
+      symbols_join = symbols.to_s
+    end
+    symbols_join = "[\"#{symbols_join}\"]"
+
+    unless delete
+      unless value
+        eval "@db#{ symbols_join }"
+      else
+        eval "@db#{ symbols_join } = value"
+        
+        if @auto_write
+          write @path, @db
+        end
+      end
+    else
+      if symbols
+        eval "@db#{ symbols_join }.delete('#{delete}')"
+      else
+        eval "@db.delete('#{delete}')"
+      end
+
+      if @auto_write
+        write @path, @db
+      end
+    end
+  end
+
+  def exist?
+    @db.empty?
+  end
+
+  def delete key, symbols = nil
+    parse(symbols, nil, key)
+  end
+
+  private
+  def open path
+    begin
+      result = String.new
+      File.open path do |f|
+        result = JSON.parse f.read
+      end
+
+      return result
+    rescue
+      return Hash.new
+    end
+  end
+
+  def write path, db
+    begin
+      create_dir path do 
+
+        f = File.new path, "w"
+        f.write JSON.pretty_generate db
+        f.close
+      end
+    end
+  end
+
+  def create_dir path, &callback
+    begin
+      dir_path = File.dirname path
+      unless Dir.exist? dir_path
+        FileUtils.mkpath dir_path
+      end
+
+      callback.call
+    rescue
+      
+    end
+  end
+end

data/lib/option_parser.rb

@@ -0,0 +1,91 @@
+class OptionParser
+
+	LEFT = 2
+	MIDDLE = 33
+
+    attr_reader :args
+
+    def self.parse(args = ARGV)
+        parser = OptionParser.new
+        yield parser
+        parser.process args
+        parser
+    end
+
+    def self.last_arg(args = ARGV)
+        args.length >= 1 ? args[args.length - 1] : nil
+    end
+
+    def initialize(args = ARGV)
+        @args = args
+        @banner = nil
+        @flags = Array.new
+    end
+
+    def banner(banner)
+        @banner = banner
+    end
+
+    def on(short_flag, long_flag, description, &block)
+        @flags << { short_flag: short_flag || '', long_flag: long_flag || '',
+            description: description || '', block: block }
+    end
+
+    def process( args = ARGV )
+        unless args.length == 0
+            args.each_with_index do |arg, i|
+                @flags.each do |flag|
+                    name = -> (type_flag) do
+                        flag[type_flag].gsub( /[a-z -]/, '' )
+                    end
+
+                    flag_strip = -> (type_flag) do
+                        flag[type_flag].sub( name.(type_flag), '' ).strip()
+                    end
+                    has_flag = -> (type_flag) { arg == flag_strip.(type_flag) }
+
+                    if has_flag.(:short_flag) or
+                    has_flag.(:long_flag)
+
+                        has_name = -> (type_flag) do
+                            name.(type_flag) != ""
+                        end
+                        value = nil
+
+                        if has_name.(:short_flag) or
+                        has_name.(:long_flag)
+                            value = args[i + 1]
+                        end
+
+                        flag[:block].call( value )
+                    end
+                end
+            end
+        else
+            flag = @flags[0]
+            flag[:block].call
+        end
+    end
+
+    def self.get_empty_spaces
+        " " * (MIDDLE + LEFT)
+    end
+
+    def to_s()
+        io = Array.new
+        if banner = @banner
+            io << banner
+            io << "\n"
+        end
+        
+        @flags.each do |flag|
+            l_flag = !flag[:long_flag].empty? ? ", #{flag[:long_flag]}" : ""
+			flags = "#{flag[:short_flag]}#{l_flag}".ljust(MIDDLE)
+			desc = flag[:description].gsub("\n", "\n#{OptionParser.get_empty_spaces}")
+            io << "".ljust(LEFT) + flags + desc
+            io << "\n"
+        end
+
+        io.join
+    end
+end

data/lib/string.rb

@@ -0,0 +1,9 @@
+class String
+  def to_b
+    if self == 'true'
+      return true
+    else
+      return false
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: cv-tool
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Filip Vrba
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-14 00:00:00.000000000 Z
+dependencies: []
+description: The tool will allow communication through a Rest API, enabling the retrieval
+  and transmission of data to and from the database. Additionally, it will provide
+  other necessary functions for launching your own CV website.
+email: filipvrbaxi@gmail.com
+executables:
+- cvtool
+extensions: []
+extra_rdoc_files: []
+files:
+- app/arguments.rb
+- app/configuration.rb
+- app/inputs.rb
+- app/main.rb
+- app/signals.rb
+- bin/cvtool
+- lib/cv_tool.rb
+- lib/cv_tool/constants.rb
+- lib/cv_tool/event.rb
+- lib/cv_tool/files.rb
+- lib/cv_tool/http.rb
+- lib/cv_tool/os.rb
+- lib/cv_tool/rest_api.rb
+- lib/cv_tool/version.rb
+- lib/json_parser.rb
+- lib/option_parser.rb
+- lib/string.rb
+homepage: https://cvfv.fly.dev/projects/cv
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/filipvrba/cv-tool-rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: CV-Tool facilitates remote manipulation of CV website.
+test_files: []