Building a Ruby CLI with Thor

#!/usr/bin/env ruby

require_relative '../lib/api-client/cli'

# lib/api-client/cli.rb

require 'dotenv/load'
require 'thor'
require 'digest'
require 'active_controller'

module ApiClient
  # The ApiClient Command Line Interface (CLI entry point, see `bin/api`)
  class CLI < Thor

    desc 'auth [BUSINESS_ACCESS_TOKEN]', 'create the `Authorization` header for the API'
    def auth(business_access_token = nil)
      business_access_token ||= ENV['BUSINESS_ACCESS_TOKEN']
      if business_access_token.blank?
        STDOUT.puts 'BUSINESS_ACCESS_TOKEN is required'
        STDOUT.puts 'You can write it in .env file to make it default'
      else
        STDOUT.puts "BUSINESS_ACCESS_TOKEN=#{business_access_token}"
        nonce = Time.now.to_i
        token = Digest::SHA256.hexdigest("#{business_access_token}#{nonce}")
        auth = ActionController::HttpAuthentication::Token.encode_credentials(token, nonce: nonce)
        STDOUT.puts auth
      end
    end
  end
end

ApiClient::CLI.start(ARGV)

# lib/api-client/locations_cli.rb

require 'thor'

module ApiClient
  class LocationsCLI < Thor
    class_option :env, type: :string, aliases: :e, default: 'development',
                        required: true, banner: 'development',
                        desc: 'The environment to use: development or staging'
    class_option :token, type: :string, aliases: :t, banner: 'BUSINESS_ACCESS_TOKEN',
                          desc: 'The business access token'

    desc 'create BUSINESS_ID FILE', 'create locations from FILE (json format)'
    option :limit, type: :numeric, aliases: :l, banner: 'number',
                    desc: 'The maximum number of locations to create'
    def create(business_id, json_file)
      ...
    end

    desc 'update BUSINESS_ID LOCATION_ID JSON', 'update a location from JSON'
    def update(business_id, location_id, json)
      ...
    end
  end
end

# lib/api-client/cli.rb

module ApiClient
  class CLI < Thor

    desc 'auth [BUSINESS_ACCESS_TOKEN]', 'create the `Authorization` header for the API'
    def auth(business_access_token = nil)
      ...
    end

    desc 'locations SUBCOMMAND ...ARGS', 'manage locations via API'
    subcommand 'locations', ApiClient::LocationsCLI
  end
end

ApiClient::CLI.start(ARGV)

# frozen_string_literal: true

require 'net/http'
require 'uri'
require 'json'
require 'digest'
require 'action_controller'

module ApiClient
  # A minimal layer over net/http to simplify sending requests to Client API
  class Http

    attr_reader :url, :token

    API_URLS = {
      staging: 'http://projectname-staging.client.com/api/v1',
      development: 'http://localhost:3000/api/v1'
    }.freeze

    METHODS = { post: Net::HTTP::Post, put: Net::HTTP::Put }.freeze

    def initialize(environment, token = nil)
      @url = API_URLS[environment.to_sym]
      @token = token

      throw "Environment not valid: #{environment}" if @url.blank?
    end

    def authorization
      return '' if @token.blank?

      nonce = Time.now.to_i
      token = Digest::SHA256.hexdigest("#{@token}#{nonce}")
      ActionController::HttpAuthentication::Token.encode_credentials(token, nonce: nonce)
    end

    def send_request(method, url, body = nil)
      uri = URI.parse(url)
      http = Net::HTTP.new(uri.host, uri.port)
      request = METHODS[method].new(uri.request_uri, header)
      request.body = body.to_json if body.present?
      http.request(request)
    end

    def header
      {
        'Content-Type' => 'application/json',
        'Authorization' => authorization
      }
    end

  end
end

# lib/api-client/api.rb

require_relative './http'

module ApiClient
  class Api

    attr_reader :http

    def initialize(environment, token = nil)
      @http = Http.new(environment, token)
    end

    def create_locations(business_id, locations)
      ...
    end

    def create_location(business_id, location)
      ...
    end

    def update_location(business_id, location_id, location)
      ...
    end

  end
end

module ApiClient
  class LocationsCLI

    ...

    desc 'update BUSINESS_ID LOCATION_ID JSON', 'update a location from JSON'
    long_desc <<-LONGDESC
    `.bin/api locations update` will use the client API to update a location.

    The BUSINESS_ID and LOCATION_ID are required

    The JSON parameter is a JSON string with the params to update (remember to enclose
    the JSON between ')

    > $ ./bin/api locations update 1e55f77d cc7a921e '{ "name": "The New Name" }' -t xt4Xg
    LONGDESC
    def update(business_id, location_id, json)
      api = ApiClient::Api.new(options[:env], options[:token])
      api.update_location(business_id, location_id, JSON.parse(json))
    end
  end
end