restup 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 821def49d7ed7b1bfe9fece4bdccf8711439f3dd
+  data.tar.gz: 22a09bc07b0613224205ef9b03a499f3f05fe0e4
+SHA512:
+  metadata.gz: 053726b4acc83c478528d144d47da2b8423f2da294f1c52ed35b9ab7dd3a20f97d580962c6e9a37fb555e5a82a36b577cfd591f5600232606f8bae36f20a5721
+  data.tar.gz: 66ef657596c00a2255485f48847c575262702167df22b4ef7014e1c2c1d6db4b57a84b366b294403d8d4b642db2ace5f2018ea47d5a1ed32747518845e44e146

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Z. D. Peacock 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+Thoom::RestUp
+=============
+
+After many years in beta, RestClient is now RestUp version 1. 
+It's mainly the same client as before, but some breaking changes have been made based on 
+feedback and experience.
+
+RestUp works out of the box with APIs that use Basic Authentication (though this is not required).
+To use other forms of authentication, custom headers can either be passed with each request
+or stored in the config file as described below.
+
+If a YAML configuration file exists (by default `.restup.yml`), the client will pull in defaults and provide several shortcut methods that can simplify using a REST-based API.
+
+If the API uses form encoded input, you can define your post in JSON format. The client
+will encode it automatically.
+
+Installation
+------------
+
+#### Gem
+For convenience, the executable and class are available as a gem on RubyGems.
+
+    gem install restup
+
+#### Docker
+The client is also available as a Docker image.
+
+To install:
+
+    docker pull thoom/restup
+
+To run:
+
+    docker run --rm -v $PWD:/usr/src/restup thoom/restup
+
+A sample shell script `restup`:
+
+    #!/bin/bash
+    docker run --rm -v $PWD:/usr/src/restup thoom/restup "@"
+
+Console
+-------
+
+    Usage: restclient [options] ENDPOINT
+            --concise                    Disables verbose output
+            --content-disposition        For responses with a filename in the Content Disposition, save the response using that filename
+            --form                       Converts JSON-formatted input and encode it as x-www-form-urlencoded
+            --response-only              Only outputs the response body
+            --response-code-only         Only outputs the response code
+            --success-only               Only outputs whether or not the request was successful
+            --cert CERTFILE              Imports cert for Client-Authentication endpoints
+        -c, --config FILE                Config file to use. Defaults to .restup.yml                                                                 -e, --env ENVIRONMENT            Sets YAML environment for the request
+        -h, --header HEADER              Sets arbitrary header passed in format "HEADER: VALUE"
+        -j, --json [c|a]                 Sets the Content-Type and/or Accept Headers to use JSON mime types (i.e. -ja)
+        -m, --method                     The HTTP method to use (defaults to GET)
+        -o, --output FILE                Save output to file passed
+        -p, --password PASSWORD          Password for Basic Authentication
+        -u, --username USERNAME          Username for Basic Authentication
+        -x, --xml [c|a]                  Sets the Content-Type and/or Accept Headers to use XML mime types (i.e. -xc)
+            --verbose                    Provides a nice UI for your API responses
+            --version                    Shows client version
+            --help [details]             Shows this message
+
+YAML config
+-----------
+
+If a file is not passed in with the `-c, --config` flag, then it will use the default `.restup.yml`.
+The client uses two different methods to find the YAML configuration file.
+It will first look in the current directory. 
+If it is not present, it will then look in the current user's home directory.
+
+This makes it possible to use restup to connect to different APIs simply by changing
+folders.
+
+    KEY          DESC
+    ----         -----
+    user:       The username. Default: blank, so disable Basic Authentication
+    pass:       The password. Default: blank, so disable Basic Authentication
+
+    url:        The base REST url
+    json:       The default JSON MIME type. Default: "application/json"
+    xml:        The default XML MIME type.  Default: "application/xml"
+
+    colors:     Hash of default color values
+      success:  Color to highlight successful messages.  Default: :green
+      warning:  Color to highlight warning messages.     Default: :yellow
+      info:     Color to highlight info messages.        Default: :yellow
+      error:    Color to highlight error messages.       Default :red
+      
+    flags:      Default command line options
+      display:  What to display by default. 
+                Values: concise, response_only, response_code_only, succcess_only, verbose
+                Default: response_only
+
+    headers:    Hash of default headers. Useful for custom headers or headers used in every request.
+                The keys for this hash are strings, not symbols like the other keys
+
+    timeout:    The number of seconds to wait for a response before timing out. Default: 300
+
+    tls_verify: When using TLS, the verify mode to use.  Values: true, false.  Default: true
+
+    xmethods:   Array of nonstandard methods that are accepted by the API. To use these methods the
+                API must support X-HTTP-Method-Override.
+
+Examples
+--------
+
+### GET Request
+
+The YAML config:
+
+    url: http://example.com/api
+    user: myname
+    pass: P@ssWord
+
+The command line:
+
+    restup -j /hello/world 
+
+To use without the config:
+
+    restclient -u myname -p P@ssWord -j http://example.com/api/hello/world
+
+Submits a GET request to `http://example/api/hello/world` with Basic Auth header using the
+user and pass values in the config.
+
+It would return JSON values. If successful, the JSON would be parsed and highlighted in __:colors::success:__. If
+the an error was returned (an HTTP response code >= 400), the body would be in __:colors::error:__.
+
+### POST Request
+
+The YAML config:
+
+    url: http://example.com/api
+    user: myname
+    pass: P@ssWord
+    headers:
+      X-Custom-Id: abc12345
+
+The command line:
+
+    restclient -m post -j /hello/world < salutation.json
+
+OR
+
+    cat salutation.json | restclient -m post /hello/world
+
+Submits a POST request to `http://example/api/hello/world` with Basic Auth header using the
+user and pass values in the config. It imports the salutation.json and passes it to the API as application/json
+content type. It would also set the `X-Custom-Id` header with every request.
+
+It would return JSON values. If successful, the JSON would be parsed and highlighted in __:colors::success:__. If
+the an error was returned (an HTTP response code >= 400), the body would be in __:colors::error:__.
+
+
+Migration From RestClient
+-------------------------
+
+To migrate:
+
+1. Rename your `.restclient.yml` file to `.restup.yml`.
+2. The CLI format changed from `restclient METHOD ENDPOINT [options]` to `restup [options] ENDPOINT`.
+3. The `-c` option is no longer available. You must use `--cert` instead.
+4. The `-m` option was created for specifying methods. So `restup -m POST ENDPOINT` instead of `restclient POST ENDPOINT`.
+5. Add `flags: { display: verbose }` to the config file return to the previous API output.
+
+License
+-------
+[MIT](LICENSE)
+
+Version History
+---------------
+[Changelog](CHANGELOG.md)

data/bin/restup

@@ -0,0 +1,230 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(File.dirname(__FILE__))) + '/lib')
+
+require 'constants'
+require 'config'
+require 'output_builder'
+require 'rest_up'
+
+require 'optparse'
+require 'json'
+require 'yaml'
+
+if ARGV.empty?
+  Thoom::SimpleOutputBuilder.new.quit(
+    'Missing required options. Use "--help" OR "--help details" for more information', false
+  )
+end
+
+DEFAULT_CONFIG = '.restup.yml'.freeze
+
+opts = {
+  cert: '',
+  config: DEFAULT_CONFIG,
+  content_disposition: false,
+  display: :default,
+  env: :default,
+  endpoint: ARGV.last,
+  form: false,
+  headers: {},
+  help: false,
+  method: 'get'
+}
+
+opts_builder = nil
+
+parser = OptionParser.new do |o|
+  o.banner = 'Usage: restup [options] ENDPOINT'
+  o.on('--concise', 'Disables verbose output') do
+    opts[:display] = :concise
+  end
+
+  o.on('--content-disposition', 'For responses with a filename in the Content Disposition, save the response using that filename') do
+    opts[:content_disposition] = true
+  end
+
+  o.on('--form', 'Converts JSON-formatted input and encode it as x-www-form-urlencoded') do
+    opts[:form] = true
+  end
+
+  o.on('--response-only', 'Only outputs the response body') do
+    opts[:display] = :response_only
+  end
+  o.on('--response-code-only', 'Only outputs the response code') do
+    opts[:display] = :response_code_only
+  end
+
+  o.on('--success-only', 'Only outputs whether or not the request was successful') do
+    opts[:display] = :success_only
+  end
+
+  o.on('--cert CERTFILE', 'Imports cert for Client-Authentication endpoints') do |cert|
+    opts[:cert] = cert
+  end
+
+  o.on('-c', '--config FILE', "Config file to use. Defaults to #{DEFAULT_CONFIG}") do |config|
+    opts[:config] = config
+  end
+
+  o.on('-e', '--env ENVIRONMENT', 'Sets YAML environment for the request') do |env|
+    opts[:env] = env.to_sym
+  end
+
+  o.on('-h', '--header HEADER', 'Sets arbitrary header passed in format "HEADER: VALUE"') do |header|
+    key, val = header.split(':')
+    opts[:headers][key.downcase.strip] = val.strip
+  end
+
+  o.on('-j', '--json [c|a]', 'Sets the Content-Type and/or Accept Headers to use JSON mime types (i.e. -ja)') do |json|
+    case json
+    when 'c', 'content-type'
+      opts[:headers]['content-type'] = :json
+    when 'a', 'accept'
+      opts[:headers]['accept'] = :json
+    else
+      opts[:headers]['content-type'] = :json
+      opts[:headers]['accept'] = :json
+    end
+  end
+
+  o.on('-m', '--method METHOD', 'Save output to file passed') do |method_name|
+    opts[:method] = method_name
+  end
+
+  o.on('-o', '--output FILE', 'Save output to file passed') do |file|
+    opts[:output_file] = file
+  end
+
+  o.on('-p', '--password PASSWORD', 'Password for Basic Authentication') do |password|
+    opts[:pass] = password
+  end
+
+  o.on('-u', '--username USERNAME', 'Username for Basic Authentication') do |username|
+    opts[:user] = username
+  end
+
+  o.on('-x', '--xml [c|a]', 'Sets the Content-Type and/or Accept Headers to use XML mime types (i.e. -xc)') do |xml|
+    case xml
+    when 'c', 'content-type'
+      opts[:headers]['content-type'] = :xml
+    when 'a', 'accept'
+      opts[:headers]['accept'] = :xml
+    else
+      opts[:headers]['content-type'] = :xml
+      opts[:headers]['accept'] = :xml
+    end
+  end
+
+  o.on('--verbose', 'Provides a nice UI for your API responses') do
+    opts[:display] = :verbose
+  end
+
+  o.on_tail('--version', 'Shows client version') do
+    Thoom::SimpleOutputBuilder.new.quit('', false)
+  end
+
+  o.on_tail('--help [details]', 'Shows this message') do |details|
+    opts_builder = o
+    opts[:help] = details == 'details' ? :details : :simple
+  end
+end
+
+begin
+  parser.parse! ARGV
+  ARGV.clear
+
+  begin
+    config = Thoom::YamlConfig.new opts[:config], opts[:env]
+  rescue Thoom::ConfigFileError
+    config = Thoom::HashConfig.new
+  end
+
+  output_builder = Thoom::DefaultOutputBuilder.new
+  new_colors = config.get(:colors, yolo: :cyan)
+
+  if new_colors.nil? || new_colors.empty?
+    output_builder.quit(Paint['Empty color: hash found in YAML configuration', output_builder.colors[:error]])
+  end
+
+  output_builder.colors.merge!(new_colors)
+
+  if opts[:help] == :details
+    output_builder.help(DEFAULT_CONFIG, opts_builder)
+  elsif opts[:help] == :simple
+    output_builder.quit(opts_builder)
+  end
+
+  if opts[:display] == :default
+    display = config.get(:flags, {})[:display]
+    opts[:display] = display.nil? ? :response_only : display.to_sym
+  end
+
+  config.set(:user, opts[:user]) if opts.key? :user
+  config.set(:pass, opts[:pass]) if opts.key? :pass
+
+  client = Thoom::RestUp.new config
+  client.method = opts[:method]
+  client.endpoint = opts[:endpoint]
+  client.cert = File.read(opts[:cert]) unless opts[:cert].empty?
+
+  opts[:headers].each do |key, val|
+    if %w(content-type accept).include? key
+      val = config.get(:json, Thoom::Constants::MIME_JSON) if val == :json
+      val = config.get(:xml, Thoom::Constants::MIME_XML) if val == :xml
+    end
+    client.headers[key] = val
+  end
+
+  if ARGF.filename != '-' || (!STDIN.tty? && !STDIN.closed?)
+    data = ARGF.read
+
+    if !client.headers.key?('content-type') || client.headers['content-type'].include?('json')
+      data = YAML.safe_load(data).to_json
+    end
+
+    if opts[:form]
+      client.headers['content-type'] = 'x-www-form-urlencoded'
+      yaml = YAML.safe_load(data)
+      data = URI.encode_www_form(yaml)
+    end
+
+    client.data = data
+  end
+
+  request = client.request
+  if %i(concise verbose).include? opts[:display]
+    output_builder.request(client, request, opts[:display] == :verbose)
+  end
+
+  # This just sets a default to JSON
+  if %w(post put patch).include?(opts[:method].downcase) && (request.content_type.nil? || request.content_type.empty?)
+    request.content_type = config.get(:json, Thoom::Constants::MIME_JSON)
+  end
+
+  before = Time.now
+  response = client.submit request
+  output_builder.response_time = (Time.now - before).round(2)
+
+  output_builder.quit(response) unless response.respond_to? :each_header
+
+  case opts[:display]
+  when :response_code_only
+    puts response.code
+  when :success_only
+    puts response.code.to_i < 400
+  when :response_only
+    puts response.body
+  else
+    output_builder.response(response, opts[:display] == :verbose)
+    output_builder.save_response(response, opts[:content_disposition], opts[:output_file])
+    puts "\n"
+  end
+rescue Timeout::Error
+  output_builder.quit Paint['Request timed out', output_builder.colors[:error]]
+rescue SystemExit
+  puts "\n"
+rescue StandardError => e
+  output_builder = output_builder.nil? ? Thoom::DefaultOutputBuilder.new : output_builder
+  output_builder.quit "#{Paint[e.message.capitalize, output_builder.colors[:error]]}\n\n"
+end

data/lib/config.rb

@@ -0,0 +1,268 @@
+module Thoom
+  class ConfigError < RuntimeError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+
+  class ConfigFileError < ConfigError
+  end
+
+  module Config
+    def config_set(config)
+      @config = config.deep_symbolize_keys
+    end
+
+    def get(key, default_val = nil)
+      key = key.to_sym
+      if @config.key?(@env) && @config[@env].key?(key)
+        @config[@env][key]
+      elsif @config.key?(:default) && @config[:default].key?(key)
+        @config[:default][key]
+      elsif @config.key? key
+        @config[key]
+      elsif !default_val.nil?
+        default_val
+      else
+        raise ConfigError, "Missing required configuration entry for #{key}"
+      end
+    end
+
+    def env=(val)
+      @env = val.to_sym
+    end
+
+    def set(key, val, env = :default)
+      env = env.to_sym
+      key = key.to_sym
+
+      @config[env] = {} unless @config.key? env
+      @config[env][key] = val
+    end
+
+    def print
+      @config.to_s
+    end
+  end
+
+  class HashConfig
+    include Config
+
+    def initialize(hash = {}, env = :default)
+      @env = env
+      config_set(hash)
+    end
+  end
+
+  class YamlConfig
+    require 'yaml'
+
+    include Config
+
+    def initialize(filename, env = :default)
+      file = File.exist?(filename) ? filename : File.expand_path("~/#{filename}")
+      raise ConfigFileError, "Configuration file #{filename} not found" unless File.exist? file
+
+      yaml = YAML.load_file file
+      raise ConfigFileError, "Configuration file #{file} is empty!" unless yaml
+
+      @env = env
+      config_set(yaml)
+    end
+  end
+end
+
+# pulled from https://raw.githubusercontent.com/rails/rails/f1bad130d0c9bd77c94e43b696adca56c46a66aa/activesupport/lib/active_support/core_ext/hash/keys.rb
+class Hash
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys do |key|
+      begin
+        key.to_sym
+      rescue
+        key
+      end
+    end
+  end
+  alias to_options symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys! do |key|
+      begin
+        key.to_sym
+      rescue
+        key
+      end
+    end
+  end
+  alias to_options! symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
+  # ArgumentError on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError, "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys do |key|
+      begin
+        key.to_sym
+      rescue
+        key
+      end
+    end
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! do |key|
+      begin
+        key.to_sym
+      rescue
+        key
+      end
+    end
+  end
+
+  private
+
+  # support methods for deep transforming nested hashes and arrays
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/constants.rb

@@ -0,0 +1,7 @@
+module Thoom
+  class Constants
+    VERSION   = '1.0'.freeze
+    MIME_JSON = 'application/json'.freeze
+    MIME_XML  = 'application/xml'.freeze
+  end
+end

data/lib/output_builder.rb

@@ -0,0 +1,302 @@
+require 'constants'
+
+require 'json'
+require 'paint'
+require 'rexml/document'
+require 'rexml/formatters/pretty'
+
+module Thoom
+  class OutputBuilder
+    attr_accessor :colors, :title_output, :response_time
+
+    def initialize(colors)
+      @colors = colors
+      @output = ''
+    end
+
+    def title(centered = true)
+      return if title_output
+
+      client_copy = "Thoom::RestUp v#{Thoom::Constants::VERSION}"
+      author_copy = '@author Z.d. Peacock <zdp@thoomtech.com>'
+      link_copy   = '@link http://github.com/thoom/restup'
+
+      if centered
+        max         = [client_copy.length, author_copy.length, link_copy.length].max + 2
+        client_copy = client_copy.center(max, ' ')
+        author_copy = author_copy.center(max, ' ')
+        link_copy   = link_copy.center(max, ' ')
+      end
+
+      @title_output = true
+      puts "\n",
+           Paint[client_copy, colors[:title_color], colors[:title_bgcolor]],
+           Paint[author_copy, colors[:subtitle_color], colors[:subtitle_bgcolor]],
+           Paint[link_copy, colors[:subtitle_color], colors[:subtitle_bgcolor]]
+    end
+
+    def header(h)
+      len = Paint.unpaint(h).length
+      l   = '-' * len
+      puts "\n#{h}\n#{l}\n"
+    end
+
+    def help(config_file, opts)
+      title
+      section 'How to use RestUp'
+
+      puts <<TEXT
+RestUp works out of the box with APIs that use Basic Authentication (though this is not required).
+To use other forms of authentication, custom headers can either be passed with each request
+or stored in the config file as described below.
+
+If a #{Paint[config_file, colors[:help_filename]]} file exists, the client will pull in defaults and provide several shortcut methods
+that can simplify using a REST-based API.
+
+If the API uses form encoded input, you can define your post in JSON format. The client
+will encode it automatically.
+TEXT
+
+      section 'Console'
+      puts opts
+
+      section 'YAML config'
+      puts <<TEXT
+If a file is not passed in with the `-c, --config` flag, then it will use the default #{Paint[config_file, colors[:help_filename]]}.
+The client uses two different methods to find the YAML configuration file. It will
+first look in the current directory. If it is not present, it will then look in the current user's
+home directory.
+
+This makes it possible to use restup to connect to different APIs simply by changing folders.
+
+KEY          DESC
+----         -----
+user:       The username. Default: blank, so disable Basic Authentication
+pass:       The password. Default: blank, so disable Basic Authentication
+
+url:        The base REST url
+json:       The default JSON MIME type. Default: "application/json"
+xml:        The default XML MIME type.  Default: "application/xml"
+
+colors:     Hash of default color values
+  success:  Color to highlight successful messages.  Default: :green
+  warning:  Color to highlight warning messages.     Default: :yellow
+  info:     Color to highlight info messages.        Default: :yellow
+  error:    Color to highlight error messages.       Default :red
+
+flags:      Default command line options
+  display:  What to display by default.
+            Values: concise, response_only, response_code_only, succcess_only, verbose
+            Default: response_only
+
+headers:    Hash of default headers. Useful for custom headers or headers used in every request.
+            The keys for this hash are strings, not symbols like the other keys
+
+timeout:    The number of seconds to wait for a response before timing out. Default: 300
+
+tls_verify: When using TLS, the verify mode to use.  Values: true, false.  Default: true
+
+xmethods:   Array of nonstandard methods that are accepted by the API. To use these methods the
+            API must support X-HTTP-Method-Override.
+TEXT
+
+      section 'Examples'
+
+      header 'GET Request'
+
+      puts <<TEXT
+The YAML config:
+url: http://example.com/api
+user: myname
+pass: P@ssWord
+
+#{Paint['restup -j /hello/world', colors[:help_sample_request]]}
+
+To use without the config:
+#{Paint['restup -u myname -p P@ssWord -j http://example.com/api/hello/world', colors[:help_sample_request]]}
+
+Submits a GET request to #{Paint['http://example/api/hello/world', colors[:help_sample_url]]} with Basic Auth header using the
+user and pass values in the config.
+
+It would return JSON values. If successful, the JSON would be parsed and highlighted in #{Paint[colors[:success].to_s.upcase, colors[:success]]}. If
+the an error was returned (an HTTP response code >= 400), the body would be in #{Paint[colors[:error].to_s.upcase, colors[:error]]}.
+TEXT
+
+      header 'POST Request'
+
+      puts <<TEXT
+The YAML config:
+url: http://example.com/api
+user: myname
+pass: P@ssWord
+headers:
+  X-Custom-Id: abc12345
+
+#{Paint['restup -m post -j /hello/world < salutation.json', colors[:help_sample_request]]}
+
+Submits a POST request to #{Paint['http://example/api/hello/world', colors[:help_sample_url]]} with Basic Auth header
+using the user and pass values in the config. It imports the salutation.json and passes it to the API as application/json
+content type. It would also set the X-Custom-Id header with every request.
+
+It would return JSON values. If successful, the JSON would be parsed and highlighted in #{Paint[colors[:success].to_s.upcase, colors[:success]]}. If
+the an error was returned (an HTTP response code >= 400), the body would be in #{Paint[colors[:error].to_s.upcase, colors[:error]]}.
+TEXT
+      exit
+    end
+
+    def section(h)
+      len = Paint.unpaint(h).length
+      l   = '-' * (len + 4)
+      puts "\n#{l}\n| #{h} |\n#{l}\n"
+    end
+
+    def xp(xml_text)
+      out = ''
+
+      formatter = REXML::Formatters::Pretty.new
+      formatter.compact = true
+      formatter.write(REXML::Document.new(xml_text), out)
+      out
+    end
+
+    def request(client, request, verbose)
+      path  = client.uri.path
+      query = ''
+      query += '?' + client.uri.query if client.uri.query
+
+      port_color      = client.uri.port == 80 ? :request_port_http : :request_port_tls
+      request_section = "REQUEST: #{Paint[client.method.upcase, colors[:request_method]]} "
+      request_section += Paint["#{client.uri.host}:", colors[:request_path]]
+      request_section += Paint[client.uri.port.to_s, colors[port_color]]
+      request_section += Paint[path, colors[:request_path]]
+      request_section += Paint[query, colors[:request_endpoint]]
+
+      unless request.respond_to? 'each_header'
+        header 'MALFORMED REQUEST'
+        quit Paint[request, colors[:error]]
+      end
+
+      if verbose
+        section request_section if verbose
+
+        header 'HEADERS'
+        request.each_header { |k, v| puts "#{k}: #{v}\n" }
+
+        if client.data
+          header 'BODY'
+
+          begin
+            puts %w(UTF-8 ASCII-8BIT).include?(client.data.encoding.to_s) ? client.data : client.data.encode('ASCII-8BIT')
+          rescue EncodingError
+            puts "Data posted, but contains non-UTF-8 data, so it's not echoed here."
+          end
+        end
+      else
+        puts "\n#{request_section}"
+      end
+    end
+
+    def response(response, verbose)
+      response_color   = response.code.to_i < 400 ? colors[:success] : colors[:error]
+      response_section = "RESPONSE: #{Paint[response.code, response_color]} (#{response_time} sec)"
+
+      if verbose || response_color == colors[:error]
+        section response_section
+        header 'HEADERS'
+        response.each_header { |k, v| puts "#{k}: #{v}\n" }
+      else
+        puts response_section
+      end
+
+      header 'BODY' if verbose
+      puts 'BODY:' unless verbose
+
+      if !response.body || response.body.empty?
+        puts Paint['NONE', colors[:info]]
+      else
+        body = response.body
+        begin
+            body.encode!('ASCII-8BIT') if body.encoding.to_s != 'ASCII-8BIT'
+
+            body = if response['content-type'].nil?
+                     body
+                   elsif response['content-type'].include? 'json'
+                     JSON.pretty_unparse(JSON.parse(body))
+                   elsif response['content-type'].include? 'xml'
+                     xp(body)
+                   else
+                     body
+               end
+            puts Paint[body, response_color]
+          rescue EncodingError => e
+            puts Paint["RESPONSE contains non-UTF-8 data, so it's not echoed here.", colors[:info]]
+          end
+      end
+    end
+
+    def save_response(response, content_disposition, output)
+      if content_disposition && output.nil? && response.to_hash.key?('content-disposition')
+        cd = response['content-disposition']
+        output = cd[cd.index('filename=') + 9..-1]
+      end
+
+      unless output.nil?
+        file = File.expand_path(output)
+        if File.exist?(File.dirname(file))
+          File.open(file, 'w') { |f| f.write response.body }
+          puts Paint["Response written to file: #{file}", colors[:info]]
+        else
+          puts Paint["Could not write to file #{file}", colors[:error]]
+        end
+      end
+    end
+
+    def quit(content, centered = true)
+      title(centered)
+      puts "\n#{content}"
+      exit
+    end
+  end
+
+  # Sets up the default color set
+  class DefaultOutputBuilder < OutputBuilder
+    def initialize
+      colors = {
+        title_color: '4D7326',
+        title_bgcolor: :white,
+
+        subtitle_color: :white,
+        subtitle_bgcolor: '4D7326',
+
+        help_filename: :yellow,
+        help_sample_request: :magenta,
+        help_sample_url: :blue,
+
+        request_method: :cyan,
+        request_path: '813b5e',
+        request_port_http: '813b5e',
+        request_port_tls: '264d73',
+        request_endpoint: :yellow,
+
+        success: '277326',
+        warning: :yellow,
+        info: :yellow,
+        error: 'c20f12'
+      }
+      super(colors)
+    end
+  end
+
+  # Outputs just the basic default colors
+  class SimpleOutputBuilder < OutputBuilder
+    def initialize
+      colors = {
+        subtitle_color: :default,
+        subtitle_bgcolor: :default,
+        title_color: :default,
+        title_bgcolor: :default
+      }
+      super(colors)
+    end
+  end
+end

data/lib/rest_up.rb

@@ -0,0 +1,154 @@
+require 'yaml'
+require 'logger'
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'config'
+require 'constants'
+
+module Thoom
+  # General Error message returned by the class
+  class RestUpError < RuntimeError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+
+  # Makes the request
+  class RestUp
+    attr_accessor :endpoint, :data, :cert
+    attr_reader :headers, :log, :method
+
+    def initialize(config = nil)
+      @config = config.nil? ? HashConfig.new : config
+      @log = Logger.new STDOUT
+
+      @uri = nil
+      @xmethods = nil
+      @headers = @config.get(:headers, {})
+      @standard_methods = %w(delete get head options patch post put)
+    end
+
+    def headers=(headers)
+      headers.each { |key, val| @headers[key.to_sym] = val }
+    end
+
+    def method=(method)
+      method.downcase!
+
+      unless @standard_methods.include?(method) || xmethods.include?(method)
+        raise RestUpError, 'Invalid Method'
+      end
+
+      if xmethods.include? method
+        headers['x-http-method-override'] = method.upcase
+        method = 'post'
+      end
+
+      @method = method
+    end
+
+    def request
+      raise RestUpError, 'Invalid URL' unless uri.respond_to?(:request_uri)
+
+      request = create_request(uri.request_uri)
+
+      add_request_headers(request)
+      add_request_body(request)
+
+      request
+    end
+
+    def http
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = @config.get(:timeout, 300)
+
+      configure_tls http
+      configure_client_cert http
+
+      http
+    end
+
+    def submit(request)
+      http.request request
+    end
+
+    def uri
+      return @uri if @uri
+      @uri = URI.parse url
+    end
+
+    def url
+      return endpoint if endpoint.start_with?('http')
+
+      @config.get(:url, '') + endpoint
+    end
+
+    private
+
+    def create_request(request_uri)
+      request = Net::HTTP.const_get(method.capitalize).new request_uri
+
+      configure_basic_auth(request)
+
+      request['User-Agent']  = 'Thoom::RestUp/' + Constants::VERSION
+      request.content_length = 0
+
+      request
+    end
+
+    def configure_basic_auth(request)
+      user = @config.get(:user, '')
+      pass = @config.get(:pass, '')
+
+      request.basic_auth(user, pass) unless user.to_s.empty? || pass.to_s.empty?
+    end
+
+    def configure_client_cert(http)
+      pem = cert.nil? ? @config.get(:cert, '') : cert
+      return if pem.empty?
+
+      begin
+        http.cert = OpenSSL::X509::Certificate.new pem
+        http.key  = OpenSSL::PKey::RSA.new pem
+      rescue OpenSSL::OpenSSLError
+        raise RestUpError, 'Invalid client certificate'
+      end
+    end
+
+    def configure_tls(http)
+      return if uri.scheme != 'https'
+      http.use_ssl = true
+
+      mode = @config.get(:tls_verify, true) ? 'VERIFY_PEER' : 'VERIFY_NONE'
+      http.verify_mode = OpenSSL::SSL.const_get(mode)
+    end
+
+    def add_request_body(request)
+      return if data.nil? || data.empty?
+
+      body = data.clone
+      request.content_length = body.length
+      request.body = body
+    end
+
+    def add_request_headers(request)
+      return unless headers.respond_to? :each
+
+      headers.each { |key, val| request[key.to_s.strip] = val.strip }
+    end
+
+    def xmethods
+      return @xmethods if @xmethods
+
+      xmethods = @config.get(:xmethods, [])
+      unless xmethods.respond_to? :map
+        raise RestUpError, 'Invalid xmethods configuration'
+      end
+
+      @xmethods = xmethods.map(&:downcase)
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: restup
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Z.d. Peacock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A class and executable for interacting with RESTful web services
+email: zdp@thoomtech.com
+executables:
+- restup
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/restup
+- lib/config.rb
+- lib/constants.rb
+- lib/output_builder.rb
+- lib/rest_up.rb
+homepage: http://github.com/thoom/restup
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: 'Thoom RestUp: A simple REST client'
+test_files: []