hatt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38589e6ed1df4b139b3339624ba5eb130548c062
+  data.tar.gz: 6b52ef37b1b0fc458b9ffd88c951e20d0efee1bc
+SHA512:
+  metadata.gz: a69fbe934e0a246fc33c7e3de4c00f5ae52fff5af334a408dc86319f6c2213fec4ca3e9963993db03c5180d7f06eaaf4a58e500411bf3141a40e5288858d7abc
+  data.tar.gz: 8e88242846ac574f6f811b5166d307aee6f8234789c3aaa1b9058a8e1e14f3ede903f57c07c726eed1d2600b3ed099619f0f5abd0cea1c0dd4017cfc1f60c473

data/Gemfile

@@ -0,0 +1,27 @@
+source :rubygems
+
+# misc things from activesupport are used
+# notifications are used to implement instrumentation
+gem 'activesupport'
+# faraday provides the basis for making http requests
+gem 'faraday'
+# when will json gem go into the standard lib anyways?
+gem 'multi_json'
+# tcfg provides the basis for configuration (hatt.yml) and environments (qa/production/etc)
+gem 'tcfg', '~> 0.2.2'
+# typhoes faraday adapter is the default for making http requests
+# provides a useful mechanism for making concurrent requests as well
+gem 'typhoeus'
+# pry is the basis of the REPL feature of the hatt cmd line tool
+gem 'pry'
+# awesome_print makes pry better
+gem 'awesome_print'
+
+group :development do
+  gem 'debase'
+  gem 'jeweler'
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'ruby-debug-ide'
+  gem 'simplecov'
+end

data/Gemfile.lock

@@ -0,0 +1,138 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (5.1.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    ast (2.3.0)
+    awesome_print (1.7.0)
+    builder (3.2.3)
+    coderay (1.1.1)
+    concurrent-ruby (1.0.5)
+    debase (0.2.1)
+      debase-ruby_core_source
+    debase-ruby_core_source (0.9.9)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    ethon (0.10.1)
+      ffi (>= 1.3.0)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.9.18)
+    git (1.3.0)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (3.5.5)
+    highline (1.7.8)
+    i18n (0.8.1)
+    jeweler (2.3.5)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api (~> 0.11.0)
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      psych (~> 2.2)
+      rake
+      rdoc
+      semver2
+    json (2.1.0)
+    jwt (1.5.6)
+    method_source (0.8.2)
+    mini_portile2 (2.1.0)
+    minitest (5.10.1)
+    multi_json (1.12.1)
+    multi_xml (0.6.0)
+    multipart-post (2.0.0)
+    nokogiri (1.6.8.1)
+      mini_portile2 (~> 2.1.0)
+    oauth2 (1.3.1)
+      faraday (>= 0.8, < 0.12)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    psych (2.2.4)
+    public_suffix (2.0.5)
+    rack (2.0.1)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    rdoc (5.1.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.48.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-debug-ide (0.6.0)
+      rake (>= 0.8.1)
+    ruby-progressbar (1.8.1)
+    semver2 (3.4.2)
+    simplecov (0.14.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    tcfg (0.2.2)
+      activesupport
+    thread_safe (0.3.6)
+    typhoeus (1.1.2)
+      ethon (>= 0.9.0)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  awesome_print
+  debase
+  faraday
+  jeweler
+  multi_json
+  pry
+  rspec
+  rubocop
+  ruby-debug-ide
+  simplecov
+  tcfg (~> 0.2.2)
+  typhoeus
+
+BUNDLED WITH
+   1.13.6

data/LICENSE.txt

@@ -0,0 +1,18 @@
+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.rdoc

@@ -0,0 +1,120 @@
+Hatt
+=======
+Do cool stuff with HTTP JSON APIs.  Designed for the real world of developing systems based on service-oriented-architecture.
+
+What is Hatt?
+----------------
+Hatt is primarily designed to be used by software teams that build HTTP JSON services.
+Hatt makes it easy to:
+* Define "macro" methods that accomplish high level goals through service calls.
+* Call services or macro methods from the command line, adhoc scripts, or programtically within any Ruby program.
+* Test services using RSpec or other testing frameworks
+* "Point" at different environments (eg. QA, Staging, Production)
+
+Hatt relies heavily on the 'convention over configuration' approach.  For very little code, you
+get a lot of functionality.
+
+Hatt is based on [Faraday](https://github.com/lostisland/faraday), thus there is basic support for making requests concurrently, and for swapping out the HTTP "adapter".
+
+Getting Started
+---------------
+Lets demo how this works using a simple example of an API that requires no
+authentication.
+
+The OpenWeatherMap is a good candidate for a simple API
+which is accessible without needing any authentication key:
+[http://api.openweathermap.org/]
+
+
+### make a project directory
+
+    mkdir weather
+    cd weather
+
+### setup hatt.yml
+
+     services:
+       owm:
+         hostname: api.openweathermap.org
+
+### make the hatts directory, and a hatt file
+
+    mkdir owm_hatts
+    touch owm_hatts/weather_hatts.rb
+
+### add method for checking weather to owm_hatts/weather.rb
+    def weather_for city
+      owm.get "/data/2.5/weather?q=#{URI.encode(city)}"
+    end
+
+### Call it from the cmd line:
+    $ hatt weather_for 'Pleasantville, NY'
+
+And that returns something like this:
+    {"coord"=>{"lon"=>-73.79169, "lat"=>41.13436}, "sys"=>{"country"=>"United States of America", "sunrise"=>1366883974, "sunset"=>1366933583}, "weather"=>[{"id"=>501, "main"=>"Rain", "description"=>"moderate rain", "icon"=>"10d"}], "base"=>"global stations", "main"=>{"temp"=>290.46, "humidity"=>26, "pressure"=>1020, "temp_min"=>289.15, "temp_max"=>292.59}, "wind"=>{"speed"=>2.06, "gust"=>4.11, "deg"=>265}, "rain"=>{"1h"=>2.32}, "clouds"=>{"all"=>0}, "dt"=>1366926419, "id"=>5131757, "name"=>"Pleasantville", "cod"=>200}
+
+Use the -v command line option and see the full request/response logged to StdOut
+
+### Script it
+Make a file called temperatures.rb with this in it:
+
+    [
+      'New York, NY',
+      'Toronto, Canada',
+      'Paris, France',
+      'Tokyo, Japan',
+      'Sydney, Australia',
+    ].each do |city|
+      weather = weather_for city
+      kelvin = weather['main']['temp']
+      celcius = (kelvin - 273.15).round
+      puts "#{city}: #{celcius} celcius"
+    end
+
+And then run the hatt script like so:
+
+    hatt -f temperatures.rb
+
+And get this nice output:
+
+    I: [04/25/13 17:59:22][hatt] - Running data script 'temperatures.rb'
+    New York, NY: 18 celcius
+    Toronto, Canada: 7 celcius
+    Paris, France: 18 celcius
+    Tokyo, Japan: 16 celcius
+    Sydney, Australia: 14 celcius
+
+### Test it
+Using the included helper module, testing an api becomes easy.  Lets setup a simple RSpec example.  Step one is create the spec folder:
+
+    mkdir spec
+
+Setup spec/spec_helper.rb with contents like:
+
+    require 'hatt/helpers'
+
+    RSpec.configure do |config|
+      config.include Hatt::Helpers
+    end
+
+Setup spec/weather_spec.rb with contents like:
+
+    require 'spec_helper'
+    describe "getting weather reports" do
+      it "should know the weather for New York City" do
+        response = weather_for 'New York, NY'
+        expected_items = ['temp', 'temp_min', 'temp_max', 'humidity', 'pressure']
+        response['main'].keys.should include(*expected_items)
+      end
+    end
+
+Run it:
+
+    gem install rspec
+    rspec
+
+And get back:
+
+    1 example, 0 failures
+
+

data/bin/hatt

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require_relative '../lib/hatt'
+
+Log = Hatt::Log
+
+Log.level = Logger::INFO
+
+# Deal with the cmd line
+def parse_cmd_line
+  options = {
+    files: [],
+    config_file: 'hatt.yml',
+    authenticate: true,
+    repl: false,
+    # by leaving environment unset, hatt will use HATT_ENVIRONMENT variable if no -e is used on cmd line
+    # environment: nil,
+  }
+
+  optparse = OptionParser.new do |opts|
+    opts.banner = %(
+      HATT HTTP API Test Tool command line utility:
+      example, run a data script: bin/hatt -f script.rb
+      example, call a dsl method:     bin/hatt <hatt dsl method name>
+
+    )
+
+    opts.on('-f', '--script=FILENAME',
+            'specify a script file to run') { |file| options[:files] << file }
+
+    opts.on('-d', '--script-dir=dir',
+            'specify a directory of hatt scripts, run all of them') { |dir| options[:files] += Dir["#{dir}/**/*.rb"] }
+
+    opts.on('-v', '--verbose',
+            'debug logging, see every request and response in detail') { Log.level = Logger::DEBUG }
+
+    opts.on('-q', '--quiet',
+            'quiet logging, warnings and errors only') { Log.level = Logger::WARN }
+
+    opts.on('-c', '--config=FILENAME',
+            'config filename') { |fn| options[:config_file] = fn }
+
+    opts.on('-e', '--environment=ENVIRONMENT',
+            'environment name') do |e|
+              # a bit unfortunate this has to be passed by env var, but it works
+              ENV['HATT_ENVIRONMENT'] = e
+            end
+
+    opts.on('-n', '--no-authenticate',
+            'Do not authenticate') { options[:authenticate] = false }
+
+    opts.on('-l', '--list', 'Print each available hatt dsl method') do
+      options[:list_hatt_methods] = true
+      options[:authenticate] = false # no point in authenticating for --list
+    end
+
+    opts.on('-r', '--pry-repl', 'Launch an interactice repl with full access to hatt services and dsl') do
+      options[:repl] = true
+    end
+  end
+  optparse.parse!
+  options
+end
+options = parse_cmd_line
+
+begin
+  hatt = Hatt.new options
+rescue TCFG::NoSuchConfigFileError => e
+  Log.error e.message
+  Log.error <<-MSG
+  \n
+  Either use -c to specify the location of your hatt config file,
+  or create a file called hatt.yml in the current directory.
+
+  Review documentation on configuration here: <TODO>
+  MSG
+  Kernel.abort
+end
+
+if options[:list_hatt_methods]
+  puts 'HATT method listing'
+
+  hatt.singleton_methods.sort.each do |meth|
+    puts " - #{meth}(#{hatt.method(meth).parameters.join(', ')})"
+  end
+
+  exit
+end
+
+if !ARGV.empty?
+  # a hatt method has been specified on the command line
+  method = ARGV.shift
+  response = hatt.send(method.to_sym, *ARGV)
+  Log.debug "HATT method '#{method}' returned:\n" + response.inspect
+  puts response
+
+elsif !options[:files].empty?
+  # some hatt files were specified on the command line
+  options[:files].each do |script_file|
+    response = hatt.run_script_file(script_file)
+    Log.debug "HATT script '#{script_file}' returtned: #{response.inspect}"
+    puts response
+  end
+
+elsif options[:repl]
+  Log.debug 'Launching PRY REPL since --pry-repl was specified....'
+  hatt.launch_pry_repl
+else
+  Kernel.abort 'Nothing to do?  use -f or give a method name on the cmd line'
+end

data/hatt.gemspec

@@ -0,0 +1,94 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: hatt 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "hatt"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Robert Schultheis"]
+  s.date = "2017-05-12"
+  s.description = "convention based approach to interfacing with an HTTP JSON API."
+  s.email = "robert.schultheis@gmail.com"
+  s.executables = ["hatt"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "bin/hatt",
+    "hatt.gemspec",
+    "lib/hatt.rb",
+    "lib/hatt/api_clients.rb",
+    "lib/hatt/base.rb",
+    "lib/hatt/blankslateproxy.rb",
+    "lib/hatt/configuration.rb",
+    "lib/hatt/dsl.rb",
+    "lib/hatt/hattmixin.rb",
+    "lib/hatt/http.rb",
+    "lib/hatt/json_helpers.rb",
+    "lib/hatt/log.rb",
+    "lib/hatt/mixin.rb",
+    "lib/hatt/singleton_mixin.rb"
+  ]
+  s.homepage = "http://github.com/rschultheis/hatt"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.5.1"
+  s.summary = "Make calls to HTTP JSON APIs with ease and confidence"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<faraday>, [">= 0"])
+      s.add_runtime_dependency(%q<multi_json>, [">= 0"])
+      s.add_runtime_dependency(%q<tcfg>, ["~> 0.2.2"])
+      s.add_runtime_dependency(%q<typhoeus>, [">= 0"])
+      s.add_runtime_dependency(%q<pry>, [">= 0"])
+      s.add_runtime_dependency(%q<awesome_print>, [">= 0"])
+      s.add_development_dependency(%q<debase>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rubocop>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug-ide>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<faraday>, [">= 0"])
+      s.add_dependency(%q<multi_json>, [">= 0"])
+      s.add_dependency(%q<tcfg>, ["~> 0.2.2"])
+      s.add_dependency(%q<typhoeus>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<awesome_print>, [">= 0"])
+      s.add_dependency(%q<debase>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rubocop>, [">= 0"])
+      s.add_dependency(%q<ruby-debug-ide>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<faraday>, [">= 0"])
+    s.add_dependency(%q<multi_json>, [">= 0"])
+    s.add_dependency(%q<tcfg>, ["~> 0.2.2"])
+    s.add_dependency(%q<typhoeus>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<awesome_print>, [">= 0"])
+    s.add_dependency(%q<debase>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rubocop>, [">= 0"])
+    s.add_dependency(%q<ruby-debug-ide>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

data/lib/hatt/api_clients.rb

@@ -0,0 +1,40 @@
+require_relative 'http'
+require_relative 'configuration'
+
+module Hatt
+  module ApiClients
+    include Hatt::Configuration
+
+    def hatt_build_client_methods
+      hatt_configuration[:hatt_services].each_pair do |svc, svc_cfg|
+        hatt_add_service svc, svc_cfg
+      end
+    end
+
+    # add a service to hatt
+    #
+    # @param name [String] the name of the service
+    # @param url [String] an absolute url to the api
+    def hatt_add_service(name, url_or_svc_cfg_hash)
+      svc_cfg = case url_or_svc_cfg_hash
+                when String
+                  { 'url' => url_or_svc_cfg_hash }
+                when Hash
+                  url_or_svc_cfg_hash
+                else
+                  raise ArgumentError, "'#{url_or_svc_cfg_hash}' is not a url string nor hash with url key"
+                end
+
+      init_config
+      services_config = hatt_configuration['hatt_services']
+      services_config[name] = svc_cfg
+      @hatt_configuration.tcfg_set 'hatt_services', services_config
+
+      @hatt_http_clients ||= {}
+      @hatt_http_clients[name] = Hatt::HTTP.new hatt_configuration['hatt_services'][name]
+      define_singleton_method name.intern do
+        @hatt_http_clients[name]
+      end
+    end
+  end
+end

data/lib/hatt/base.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+require_relative 'mixin'
+require_relative 'singleton_mixin'
+
+module Hatt
+  class << self
+    include Hatt::Mixin
+
+    def new(options = {})
+      options = ActiveSupport::HashWithIndifferentAccess.new options
+      hatt_instance = Class.new { include Hatt::Mixin }.new
+      hatt_instance.hatt_config_file options.fetch(:config_file, 'hatt.yml')
+      hatt_instance.hatt_initialize
+      hatt_instance
+    end
+  end
+end

data/lib/hatt/blankslateproxy.rb

@@ -0,0 +1,33 @@
+module Hatt
+  # A simple 'blankslate' class which is used to avoid namespace polution
+  # Provides a proxy to a parent class, in order to allow access to other hatt methods like http service objects
+  #
+  # TODO: Figure out if can/should use a BasicObject here.  I know it wont work right now
+  # because the binding method of Object is needed and not in BasicObject
+  #
+  class BlankSlateProxy < Object
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def method_missing(method_id, *arguments, &block)
+      if parent_has_method?(method_id)
+        @parent.send(method_id, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    def parent_has_method?(name, include_private = false)
+      if include_private
+        @parent.methods.include?(name.to_sym)
+      else
+        @parent.public_methods.include?(name.to_sym)
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      parent_has_method?(name, include_private) || super
+    end
+  end
+end

data/lib/hatt/configuration.rb

@@ -0,0 +1,85 @@
+require 'uri'
+
+require 'tcfg/tcfg_base'
+
+module Hatt
+  module Configuration
+    DEFAULT_CONFIG_FILE = 'hatt.yml'.freeze
+    DEFAULT_HATT_GLOBS = ['*_hattdsl/*_hattdsl.rb'].freeze
+
+    def hatt_configuration
+      init_config
+      @hatt_configuration.tcfg
+    end
+
+    def hatt_config_file=(filename)
+      @hatt_config_file = filename
+      init_config
+      self
+    end
+    alias hatt_config_file hatt_config_file=
+
+    private
+
+    def hatt_config_file_path
+      if instance_variable_defined? :@hatt_config_file and not @hatt_config_file.nil?
+        File.expand_path @hatt_config_file
+      elsif File.exist? DEFAULT_CONFIG_FILE
+        File.expand_path DEFAULT_CONFIG_FILE
+      else
+        nil
+      end
+    end
+
+    # ensure the configuration is resolved and ready to use
+    def init_config
+      unless instance_variable_defined? :@hatt_configuration
+        @hatt_configuration = TCFG::Base.new
+
+        # build up some default configuration
+        @hatt_configuration.tcfg_set 'hatt_services', {}
+        @hatt_configuration.tcfg_set 'hatt_globs', DEFAULT_HATT_GLOBS
+
+        @hatt_configuration.tcfg_set_env_var_prefix 'HATT_'
+      end
+
+      if hatt_config_file_path
+        # if a config file was specified, we assume it exists
+        @hatt_configuration.tcfg_config_file hatt_config_file_path
+      else
+        Log.warn 'No configuration file specified or found. Make a hatt.yml file and point hatt at it.'
+      end
+      @hatt_configuration.tcfg_set 'hatt_config_file', hatt_config_file_path
+
+      normalize_services_config @hatt_configuration
+
+      nil
+    end
+
+    def normalize_services_config(cfg)
+      services = cfg['hatt_services']
+      services.each_pair do |svc, svc_cfg|
+        # add the name
+        svc_cfg['name'] = svc
+
+        unless svc_cfg.key? :url
+          raise ConfigurationError, "url for service '#{svc_cfg['name']}' is not defined"
+        end
+
+        unless svc_cfg['url'] =~ URI::ABS_URI
+          raise ConfigurationError, "url for service '#{svc_cfg['name']}' is not a proper absolute URL: #{svc_cfg['url']}"
+        end
+
+        parsed = URI.parse svc_cfg['url']
+
+        svc_cfg['base_uri'] ||= parsed.path
+
+        svc_cfg['faraday_url'] = "#{parsed.scheme}://#{parsed.host}:#{parsed.port}"
+      end
+
+      cfg.tcfg_set 'hatt_services', services
+    end
+  end
+
+  class ConfigurationError < StandardError; end
+end