hatt 0.0.1

data/lib/hatt/dsl.rb

@@ -0,0 +1,62 @@
+require_relative 'configuration'
+require_relative 'log'
+
+module Hatt
+  module DSL
+    include Hatt::Configuration
+    include Hatt::Log
+
+    def load_hatts_using_configuration
+      hatt_globs = hatt_configuration['hatt_globs']
+      if hatt_configuration['hatt_config_file']
+        debug "Using HATT configuration file: #{hatt_configuration['hatt_config_file']}"
+        glob_home_dir = File.dirname hatt_configuration['hatt_config_file']
+        hatt_globs.map! { |g| File.join glob_home_dir, g }
+      else
+        debug 'Not using a hatt configuration file (none defined).'
+      end
+      if hatt_globs.is_a? Array
+        hatt_globs.each do |gg|
+          hatt_load_hatt_glob gg
+        end
+      end
+      nil
+    end
+
+    def hatt_load_hatt_glob(glob)
+      globbed_files = Dir[glob]
+      Log.debug "Found '#{globbed_files.length}' hatt files using hatt glob '#{glob}'"
+      Dir[glob].each do |filename|
+        hatt_load_hatt_file filename
+      end
+    end
+
+    def hatt_load_hatt_file(filename)
+      Log.debug "Loading hatt file '#{filename}'"
+
+      unless File.exist? filename
+        raise HattNoSuchHattFile, "No such hatt file '#{filename}'"
+      end
+
+      # by evaling in a anonymous module, we protect this class's namespace
+      anon_mod = Module.new
+      with_local_load_path File.dirname(filename) do
+        anon_mod.class_eval(IO.read(filename), filename, 1)
+      end
+      extend anon_mod
+    end
+
+    private
+
+    def with_local_load_path(load_path, &block)
+      $LOAD_PATH << load_path
+      rtn = yield block
+      # delete only the first occurrence, in case something else if changing load path too
+      idx = $LOAD_PATH.index(load_path)
+      $LOAD_PATH.delete_at(idx) if idx
+      rtn
+    end
+  end
+
+  class HattNoSuchHattFile < StandardError; end
+end

data/lib/hatt/hattmixin.rb

@@ -0,0 +1,21 @@
+require_relative 'configuration'
+require_relative 'api_clients'
+require_relative 'dsl'
+
+module Hatt
+  module HattMixin
+    include Hatt::Configuration
+    include Hatt::DSL
+    include Hatt::ApiClients
+
+    def initialize(*opts)
+      hatt_initialize
+      super(*opts)
+    end
+
+    def hatt_initialize
+      hatt_build_client_methods
+      load_hatts_using_configuration
+    end
+  end
+end

data/lib/hatt/http.rb

@@ -0,0 +1,243 @@
+require 'faraday'
+require 'typhoeus'
+require 'typhoeus/adapters/faraday' # https://github.com/typhoeus/typhoeus/issues/226#issuecomment-9919517
+require 'active_support/notifications'
+
+require 'yaml'
+
+require_relative 'json_helpers'
+require_relative 'log'
+
+module Hatt
+  class HTTP
+    include Hatt::Log
+    include Hatt::JsonHelpers
+
+    def initialize(config)
+      @config = config
+      @name = @config[:name]
+      @base_uri = @config[:base_uri]
+      @log_headers = @config.fetch(:log_headers, true)
+      @log_bodies = @config.fetch(:log_bodies, true)
+
+      logger.debug "Configuring service:\n#{@config.to_hash.to_yaml}\n"
+
+      @faraday_connection = Faraday.new @config[:faraday_url] do |conn_builder|
+        # do our own logging
+        # conn_builder.response logger: logger
+        # conn_builder.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+        conn_builder.adapter @config.fetch(:adapter, :typhoeus).intern
+        conn_builder.ssl[:verify] = false if @config[:ignore_ssl_cert]
+
+        # defaulting this to flat adapter avoids issues when duplicating parameters
+        conn_builder.options[:params_encoder] = Faraday.const_get(@config.fetch(:params_encoder, 'FlatParamsEncoder'))
+
+        # this nonsense dont work?!  https://github.com/lostisland/faraday_middleware/issues/76
+        # conn_builder.use :instrumentation
+      end
+
+      @headers = {
+        'accept' => 'application/json',
+        'content-type' => 'application/json'
+      }
+      if @config[:default_headers]
+        logger.debug 'Default headers configured: ' + @config[:default_headers].inspect
+        @config[:default_headers].each_pair do |k, v|
+          @headers[k.to_s] = v.to_s
+        end
+      end
+      @default_timeout = @config.fetch(:timeout, 10)
+      logger.info "Initialized hatt service '#{@name}'"
+    end
+
+    def stubs
+      stubs = Faraday::Adapter::Test::Stubs.new
+      @faraday_connection = Faraday.new @config[:faraday_url] do |conn_builder|
+        conn_builder.adapter :test, stubs
+      end
+      stubs
+    end
+
+    # allow stubbing http if we are testing
+    attr_reader :http if defined?(RSpec)
+    attr_reader :name, :config, :faraday_connection
+    attr_accessor :headers # allows for doing some fancy stuff in threading
+
+    # this is useful for testing apis, and other times
+    # you want to interrogate the http details of a response
+    attr_reader :last_request, :last_response
+
+    def in_parallel(&blk)
+      @faraday_connection.headers = @headers
+      @faraday_connection.in_parallel(&blk)
+    end
+
+    # do_request performs the actual request, and does associated logging
+    # options can include:
+    # - :timeout, which specifies num secs the request should timeout in
+    #   (this turns out to be kind of annoying to implement)
+    def do_request(method, path, obj = nil, options = {})
+      # hatt clients pass in path possibly including query params.
+      # Faraday needs the query and path seperately.
+      parsed_uri = URI.parse make_path(path)
+      # faraday needs the request params as a hash.
+      # this turns out to be non-trivial
+      query_hash = if parsed_uri.query
+                     cgi_hash = CGI.parse(parsed_uri.query)
+                     # this next line accounts for one param having multiple values
+                     cgi_hash.each_with_object({}) { |(k, v), h| h[k] = v[1] ? v : v.first; }
+                   end
+
+      req_headers = make_headers(options)
+
+      body = if options[:form]
+               URI.encode_www_form obj
+             else
+               jsonify(obj)
+      end
+
+
+      log_request(method, parsed_uri, query_hash, headers, body)
+
+      # doing it this way avoids problem with OPTIONS method: https://github.com/lostisland/faraday/issues/305
+      response = nil
+      metrics_obj = { method: method, service: @name, path: parsed_uri.path }
+      ActiveSupport::Notifications.instrument('request.hatt', metrics_obj) do
+        response = @faraday_connection.run_request(method, nil, nil, nil) do |req|
+          req.path = parsed_uri.path
+          req.params = metrics_obj[:params] = query_hash if query_hash
+
+          req.headers = req_headers
+          req.body = body
+          req.options[:timeout] = options.fetch(:timeout, @default_timeout)
+        end
+        metrics_obj[:response] = response
+      end
+
+      logger.info "Request status: (#{response.status}) #{@name}: #{method.to_s.upcase} #{path}"
+      @last_request = {
+        method: method,
+        path: parsed_uri.path,
+        query: parsed_uri.query,
+        headers: req_headers,
+        body: body
+      }
+      @last_response = response
+
+      response_obj = objectify response.body
+
+      log_response(response, response_obj)
+
+      raise RequestException.new(nil, response) unless response.status >= 200 && response.status < 300
+
+      response_obj
+    end
+
+    def get(path, options = {})
+      do_request :get, path, nil, options
+    end
+
+    def head(path, options = {})
+      do_request :head, path, nil, options
+    end
+
+    def options(path, options = {})
+      do_request :options, path, nil, options
+    end
+
+    def delete(path, options = {})
+      do_request :delete, path, nil, options
+    end
+
+    def post(path, obj, options = {})
+      do_request :post, path, obj, options
+    end
+
+    def put(path, obj, options = {})
+      do_request :put, path, obj, options
+    end
+
+    def patch(path, obj, options = {})
+      do_request :patch, path, obj, options
+    end
+
+    def post_form(path, params, options = {})
+      do_request :post, path, params, options.merge(form: true)
+    end
+
+    # convenience method for accessing the last response status code
+    def last_response_status
+      @last_response.status
+    end
+
+    private
+
+    # add base uri to request
+    def make_path(path_suffix)
+      if @base_uri
+        @base_uri + path_suffix
+      else
+        path_suffix
+      end
+    end
+
+    def make_headers(options)
+      headers = if options[:additional_headers]
+                  @headers.merge options[:additional_headers]
+                elsif options[:headers]
+                  options[:headers]
+                else
+                  @headers.clone
+      end
+      headers['content-type'] = 'application/x-www-form-urlencoded' if options[:form]
+      headers
+    end
+
+    def log_request(method, parsed_uri, query_hash={}, headers, body)
+      # log the request
+      logger.debug [
+        "Doing request: #{@name}: #{method.to_s.upcase} #{parsed_uri.path}?#{query_hash.is_a?(Hash) ? URI.encode_www_form(query_hash) : ''}",
+        @log_headers ? ['Request Headers:',
+                        headers.map { |k, v| "#{k}: #{v.inspect}" }] : nil,
+        @log_bodies ? ['Request Body:', body] : nil
+      ].flatten.compact.join("\n")
+    end
+
+    def log_response(response, response_obj)
+      if response.headers['content-type'] =~ /json/
+        logger.debug [
+          'Response Details:',
+          @log_headers ? ['Response Headers:',
+                          response.headers.map { |k, v| "#{k}: #{v.inspect}" }] : nil,
+          @log_bodies ? ['Response Body:', jsonify(response_obj)] : nil,
+          ''
+        ].flatten.compact.join("\n")
+      end
+    end
+
+  end
+
+  class RequestException < RuntimeError
+    include Hatt::JsonHelpers
+
+    def initialize(request, response)
+      @request = request
+      @response = response
+    end
+    attr_reader :request, :response
+
+    # this makes good info show up in rspec reports
+    def to_s
+      "#{self.class}\nResponseCode: #{code}\nResponseBody:\n#{body}"
+    end
+
+    # shortcut methods
+    def code
+      @response.status
+    end
+
+    def body
+      objectify(@response.body)
+    end
+  end
+end

data/lib/hatt/json_helpers.rb

@@ -0,0 +1,34 @@
+require 'json'
+
+module Hatt
+  module JsonHelpers
+    # always returns a string, intended for request bodies
+    # every attempt is made to ensure string is valid json
+    # but if that is not possible, then its returned as is
+    def jsonify(obj)
+      case obj
+      when String
+        JSON.pretty_generate(JSON.parse(obj))
+      when Hash, Array
+        JSON.pretty_generate(obj)
+      else
+        obj.to_s
+      end
+    rescue Exception
+      obj.to_s
+    end
+
+    # attempts to parse json strings into native ruby objects
+    def objectify(json_string)
+      return nil if json_string.nil? || json_string == ''
+      case json_string
+      when Hash, Array
+        return json_string
+      else
+        JSON.parse(json_string.to_s)
+      end
+    rescue Exception
+      json_string
+    end
+  end
+end

data/lib/hatt/log.rb

@@ -0,0 +1,43 @@
+require 'logger'
+
+module Hatt
+  module Log
+    extend self
+
+    HattFormatter = proc do |severity, datetime, progname, msg|
+      "#{severity[0]}: [#{datetime.strftime('%m/%d/%y %H:%M:%S')}][#{progname}] - #{msg}\n"
+    end
+
+    @@loggers = []
+    def loggers
+      @@loggers
+    end
+
+    def add_logger(handle)
+      new_logger = Logger.new handle
+      new_logger.progname = 'hatt'
+      new_logger.formatter = HattFormatter
+      @@loggers << new_logger
+    end
+
+    add_logger(STDOUT)
+
+    def level=(log_level)
+      loggers.each { |logger| logger.level = log_level }
+    end
+
+    def log(level, msg)
+      loggers.each { |logger| logger.send(level, msg) }
+    end
+
+    %i[fatal error warn info debug].each do |log_method|
+      define_method log_method do |msg|
+        log(log_method, msg)
+      end
+    end
+
+    def logger
+      self
+    end
+  end
+end

data/lib/hatt/mixin.rb

@@ -0,0 +1,33 @@
+require_relative 'configuration'
+require_relative 'api_clients'
+require_relative 'dsl'
+require_relative 'blankslateproxy'
+
+module Hatt
+  module Mixin
+    include Hatt::Configuration
+    include Hatt::Log
+    include Hatt::ApiClients
+    include Hatt::DSL
+
+    def hatt_initialize
+      hatt_build_client_methods
+      load_hatts_using_configuration
+      self
+    end
+
+    def run_script_file(filename)
+      info "Running data script '#{filename}'"
+      raise(ArgumentError, "No such file '#{filename}'") unless File.exist? filename
+      # by running in a anonymous class, we protect this class's namespace
+      anon_class = BlankSlateProxy.new(self)
+      with_local_load_path File.dirname(filename) do
+        anon_class.instance_eval(IO.read(filename), filename, 1)
+      end
+    end
+
+    def launch_pry_repl
+      require 'pry';binding.pry
+    end
+  end
+end

data/lib/hatt/singleton_mixin.rb

@@ -0,0 +1,34 @@
+require_relative 'mixin'
+
+module Hatt
+  module SingletonMixin
+    class InitOnceHattClass
+      include Hatt::Mixin
+    end
+
+    def hatt_instance
+      @@hatt_instance ||= InitOnceHattClass.new
+    end
+    module_function :hatt_instance
+
+    def method_missing(method_id, *arguments, &block)
+      if hatt_instance_has_method?(method_id)
+        hatt_instance.send(method_id, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    def hatt_instance_has_method?(name, include_private = false)
+      if include_private
+        hatt_instance.methods.include?(name.to_sym)
+      else
+        hatt_instance.public_methods.include?(name.to_sym)
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      hatt_instance_has_method?(name, include_private) || super
+    end
+  end
+end

data/lib/hatt.rb

@@ -0,0 +1 @@
+require_relative 'hatt/base'