Ruby script implementation

Question

I created a script to automate the task of uploading a CSV file to Box. I have a couple of files a Box client and a MySQL client. I create an instance of both on the function.rb file which is the one below. I wonder if there is anything to improve? if there are principles I'm not following or if I'm breaking best practices.

Is there anything that can be improved?

require 'json'
require 'date'
require 'dotenv/load'
require 'fileutils'
require 'csv'
require 'logger'
require './my_sql'
require './box_api'
require 'pry'

begin
  year = ARGV[0]
  month = ARGV[1]
  day = ARGV[2]

  search_timestamp = Time.new(year, month, day).utc

  db_client = MySQL.new(search_timestamp)

  emails = db_client.get_emails_from_db
  return 'No new emails found' if emails.entries.empty?

  box = BoxApi.new(ENV['BOX_USER_ID'])

  date = DateTime.now.strftime("%m-%d-%Y").to_s
  file_name = "access-emails-#{date}"

  CSV.open("./tmp/#{file_name}.csv", "wb") do |csv|
    emails.entries.each do |entrie|
      csv << [entrie.values[0], entrie.values[1]]
    end
  end

  box.upload_file_to_box("./tmp/#{file_name}.csv", file_name, ENV['BOX_FOLDER_ID'])

  FileUtils.rm("./tmp/#{file_name}.csv")

  puts "successfully uploaded CSV file to Box"
rescue StandardError => e
  logger = Logger.new(STDOUT)
  logger.level = ENV.fetch('LOG_LEVEL', Logger::INFO)
  logger.datetime_format = '%Y-%m-%d %H:%M:%S '
  logger.error("msg: #{e}, trace: #{e.backtrace.join("\n")}")
end

Answer 1

I think your script would benefit from some object oriented composition. Basically you have three different concerns.

• Config
• File backup (select from database and storage in CSV)
• File upload

A few things could change now, for instance backup from a different source (different database, cloud etc), upload to a different remote service (e.g. dropbox). Additionally, having small composable objects would make it easier to test this.

Here are some examples how to compose your script more object oriented.

Config

We could use an OpenStruct to store our config data. This way we only need to write our environment variables once, if we want to change them later there is only one place to update them.

require 'ostruct'

config = OpenStruct.new(
  year: ARGV[0],
  month: ARGV[1],
  day: ARGV[2],
  box_user_id: ENV['BOX_USER_ID'],
  box_folder_id: ENV['BOX_FOLDER_ID']
)

FileBackup

We can extract a backup file which just excepts rows and writes them to a CSV file. The dependency injection makes it also easier to test this (e.g. inject the data to write and the test directory)

class BackupFile
  def initialize(rows:, date: DateTime.now.strftime("%m-%d-%Y").to_s, directory: "./tmp")
    @rows = rows
    @date = date
  end

  def save
    CSV.open(full_path, "wb") do |csv|
      rows.each do |entry|
        csv << [entry.values[0], entry.values[1]]
      end
    end
  end

  def full_path
    File.join(directory, filename)
  end

  def delete
    FileUtils.rm(full_path)
  end

  private

  attr_reader :rows, :date

  def file_name
    "access-emails-#{date}"
  end
end


db_client = MySQL.new(search_timestamp)
emails = db_client.get_emails_from_db
return 'No new emails found' if emails.entries.empty?

file = BackupFile.new(emails.entries)
file.save

Upload

The uploader accepts a client, path and remote folder. Also notice that we have an adapter around the BoxApi to implement a common interface upload. If we want to swap it out to upload to Dropbox, we only need to write a DropboxClient adapter which we can inject into the uploader. To test, we can write even a TestClient.

class Uploader
  def initialize(client:, path:, remote_folder:)
    @client = client
    @path = path
    @remote_folder = remote_folder
  end

  def upload
    client.upload(path, file_name, remote_folder)
  end

  private

  attr_reader :client, :path, :remote_folder

  def file_name
    File.basename(path)
  end
end

class BoxClient
  def initialize(client:, box_user_id:)
    @client = client.new(box_user_id)
  end

  def upload(path, file_name, remote_folder)
    client.upload_file_to_box(path, file_name, remote_folder)
  end

  private

  attr_reader :client
end

Error handling

I would move the error handling into the classes directly and also inject the logger. Something like this:

class BoxClient
  def initialize(client:, box_user_id:, logger: Logger.new)
    @client = client.new(box_user_id)
  end

  def upload(path, file_name, remote_folder)
    client.upload_file_to_box(path, file_name, remote_folder)
  rescue BoxError =>
    logger.error("Upload failed: #{e.message}")
  end

  private

  attr_reader :client
end