pipekit 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0ff8c19ce8cb4d0ec668801e0f97bc981a627cc
-  data.tar.gz: 4b6c505ab661d40acbb16b7c1cd48e082e02e1d8
+  metadata.gz: a97ca3462a69b58e56337a81273147db6d6b81ca
+  data.tar.gz: a58a9d65ecd33575e907d124a69670692843e8e1
 SHA512:
-  metadata.gz: 3a49869edcdfc81a14fd578778040276cbacf1a7d3e5c6286f05f6623b34f00f7cb9d794dad8e7d89ea550e17af5ef507613ce385330bb23d547ed95e57e6e18
-  data.tar.gz: 195663112064866b3027928bccf9ebacc8a6bed8e7e7017cfa59a24f0fcf37306ecc2c6d0a65d2d08c1fb1771c3d93895d9ad69be38d31c5862c553e6acf76ee
+  metadata.gz: 09e9a02a4d5021799ca0cf39a96b55d7c0b5a136c8f0427428037f395034ce203c575421fbacc36559198676fce62f3c3f24ed6b07b99cb8594ad4173d3b8f0b
+  data.tar.gz: 649b62d3e62ae41873880705282876663943b8e0ce38659482814fde8db3140ba8617bdf54a9905b2888679e0be71cdeb6cf7d05d0fc9862b361a32994f3b70b

data/lib/pipekit/config.rb

@@ -0,0 +1,105 @@
+module Pipekit
+  class Config
+    class << self
+
+      attr_writer :file_path
+
+      # Finds the field name in the config from the Pipedrive ID
+      #
+      # Example
+      #
+      #   Config.field_name(:person, "asbasdfasc2343443")
+      #     # => "middle_name"
+      #
+      #   Config.field_name(:person, "name")
+      #     # => "name"
+      def field_name(resource, key)
+        custom_fields(resource)
+          .invert
+          .fetch(key.to_s, key.to_s)
+      end
+
+      # Finds the Pipedrive field ID from the config
+      #
+      # Example
+      #
+      #   Config.field_id(:person, "middle_name")
+      #     # => "asbasdfasc2343443"
+      #
+      #   Config.field_id(:person, "name")
+      #     # => "name"
+      def field_id(resource, key)
+        custom_fields(resource)
+          .fetch(key.to_s, key.to_s)
+      end
+
+      # Finds the Pipedrive field value from the config
+      # translating from a Pipedrive ID in the config if one exists for that
+      # field/value
+      #
+      # Example
+      #
+      #   Config.field_value(:person, "inteview_quality", 66)
+      #     # => "Amazing"
+      #
+      #   Config.field_value(:person, "inteview_quality", "value_not_there")
+      #     # => "value_not_there"
+      def field_value(resource, field, value)
+        custom_field_values(resource, field)
+          .fetch(value, value)
+      end
+
+      # Finds the Pipedrive field value ID from the config if one exists for that
+      # field/value
+      #
+      # Example
+      #
+      #   Config.field_value_id(:person, "inteview_quality", "Amazing")
+      #     # => 66
+      #
+      #   Config.field_value_id(:person, "inteview_quality", "value_not_there")
+      #     # => "value_not_there"
+      def field_value_id(resource, field, value)
+        custom_field_values(resource, field)
+          .invert
+          .fetch(value, value)
+      end
+
+      def fetch(key, default = nil)
+        config.fetch(key.to_s, default)
+      end
+
+      def custom_fields(resource)
+        fetch("fields", {})
+          .fetch(resource.to_s, {})
+      end
+
+      def custom_field_values(resource, field)
+        fetch("field_values", {})
+          .fetch(resource.to_s, {})
+          .fetch(field.to_s, {})
+      end
+
+      def file_path
+        @file_path || raise_config_error
+      end
+
+      private
+
+      def config
+        @config ||= load_config
+      end
+
+      def raise_config_error
+        raise NotSetError, "You need to create a yaml file with your Pipedrive config and set the path to the file using `Pipekit.config_file_path = 'path/to/file.yml'`"
+      end
+
+      def load_config
+        yaml = ERB.new(File.read(file_path)).result
+        YAML.load(yaml)
+      end
+    end
+
+    NotSetError = Class.new(Exception)
+  end
+end

data/lib/pipekit/deal.rb

@@ -2,8 +2,19 @@ module Pipekit
   class Deal
     include Repository
 
-    def get_by_person_id(person_id)
-      request.get("/#{Pipekit::Person.uri}/#{person_id}/#{self.class.uri}")
+    def get_by_person_id(person_id, person_repo: Person.new)
+      raise UnknownPersonError, "No person ID supplied when getting deals by person ID" unless person_id
+      person_repo.find_deals(person_id)
+    end
+
+    # Finds a person by their email, then finds the first deal related to that
+    # person and updates it with the params provided
+    def update_by_person(email, params, person_repo: Person.new)
+      person = person_repo.find_by(email: email)
+      deal = get_by_person_id(person[:id], person_repo: person_repo).first
+      update(deal[:id], params)
     end
   end
+
+  UnknownPersonError = Class.new(StandardError)
 end

data/lib/pipekit/deal_field.rb

@@ -0,0 +1,6 @@
+module Pipekit
+  class DealField
+    include Repository
+    include FieldRepository
+  end
+end

data/lib/pipekit/field_repository.rb

@@ -0,0 +1,25 @@
+module Pipekit
+  module FieldRepository
+      def get_by_key(key)
+        key = Config.field_id(parent_resource, key)
+        search_fields("key", key)
+      end
+
+      def get_by_name(name)
+        search_fields("name", name)
+      end
+
+      private
+
+      def search_fields(field_element, value)
+        result = request.get.select { |element| element[field_element] == value }
+
+        raise ResourceNotFoundError.new("#{parent_resource}Field searching by element #{field_element} for #{value} could not be found") if result.empty?
+        result
+      end
+
+      def parent_resource
+        resource.chomp("Field")
+      end
+  end
+end

data/lib/pipekit/person.rb

@@ -3,11 +3,22 @@ module Pipekit
     include Repository
 
     def get_by_email(email)
-      request.get("/#{uri}/find", term: email, search_by_email: 1)
+      request.get("find", term: email, search_by_email: 1)
     end
 
     def get_by_name(name)
-      request.get("/#{uri}/find", term: name)
+      request.get("find", term: name)
+    end
+
+    def create_or_update(fields)
+      person = find_by(email: fields[:email])
+      update(person["id"], fields)
+    rescue ResourceNotFoundError
+      create(fields)
+    end
+
+    def find_deals(id)
+      request.get("#{id}/deals")
     end
   end
 end

data/lib/pipekit/person_field.rb

@@ -1,15 +1,6 @@
 module Pipekit
   class PersonField
     include Repository
-
-    def get_by_id(id)
-      request.get("/#{uri}").select { |element| element["id"] == id }
-    end
-
-    def get_by_key(key)
-      custom_field_key = request.config["people_fields"][key] rescue nil
-      key = custom_field_key || key
-      request.get("/#{uri}").select { |element| element["key"] == key }
-    end
+    include FieldRepository
   end
 end

data/lib/pipekit/repository.rb

@@ -1,13 +1,12 @@
-class ConfigNotSetError < Exception; end
 module Pipekit
   module Repository
 
-    def initialize(request = Pipekit::Request.new)
-      @request = request
+    def initialize(request = nil)
+      @request = request || Request.new(resource)
     end
 
     def all
-      request.get("/#{uri}")
+      get
     end
 
     # Public: Get all records from Pipedrive by **one** of the record's fields.
@@ -21,8 +20,11 @@ module Pipekit
     #   where(id: 123)
     #
     # Returns array of Hashes.
-    def where(options)
+    def where(options, raise_error = false)
       send("get_by_#{options.keys.first}", options.values.first)
+    rescue ResourceNotFoundError => error
+      raise error if raise_error
+      []
     end
 
     # Public: Get the first record by **one** field from Pipedrive.
@@ -37,7 +39,7 @@ module Pipekit
     #
     # Returns a Hash or nil if none found.
     def find_by(options)
-      where(options).first
+      where(options, true).first
     end
 
     # Public: Create a record on Pipedrive.
@@ -50,7 +52,7 @@ module Pipekit
     #
     # Returns nothing.
     def create(fields)
-      request.post("/#{uri}", fields)
+      request.post(fields)
     end
 
     # Public: Updates a record on Pipedrive.
@@ -63,15 +65,17 @@ module Pipekit
     #
     # Returns nothing.
     def update(id, fields)
-      request.put("/#{uri}/#{id}", fields)
+      request.put(id, fields)
     end
 
     def self.included(base)
-      base.send :extend, ClassMethods
+      base.extend(ClassMethods)
     end
 
     module ClassMethods
-      attr_accessor :uri
+      def resource
+        to_s.split("::").last.tap { |name| name[0] = name[0].downcase }
+      end
     end
 
     private
@@ -85,18 +89,21 @@ module Pipekit
       get_by_field(field: field, value: args[0])
     end
 
+    def get(id = nil)
+      request.get(id)
+    end
+
     def get_by_id(id)
-      [request.get("/#{uri}/#{id}")]
+      [get(id)]
     end
 
     def get_by_field(field:, value:)
-      result = request.search_by_field(type: uri, field: field, value: value)
+      result = request.search_by_field(field: field, value: value)
       result.map { |item| get_by_id(item["id"]) }.flatten
     end
 
-    def uri
-      class_name = self.class.to_s.split("::").last
-      "#{class_name.downcase}s"
+    def resource
+      self.class.resource
     end
   end
 end

data/lib/pipekit/request.rb

@@ -5,10 +5,16 @@ module Pipekit
     include HTTParty
 
     PIPEDRIVE_URL = "https://api.pipedrive.com/v1"
+    DEFAULT_PAGINATION_LIMIT = 500
 
     base_uri PIPEDRIVE_URL
     format :json
 
+    def initialize(resource)
+      @resource = resource
+      self.class.debug_output $stdout if Config.fetch("debug_requests")
+    end
+
     # Public: Pipedrive /searchField API call.
     #
     # type - Type of the field:
@@ -20,50 +26,97 @@ module Pipekit
     #
     # Examples
     #
-    #   search_by_field(type: :person, field: :cohort, value: 119)
-    #   search_by_field(type: :person, field: :github_username, value: "octocat")
+    #   search_by_field(field: :cohort, value: 119)
+    #   search_by_field(field: :github_username, value: "octocat")
     #
-    # Returns an array of Hashes or nil.
-    def search_by_field(type:, field:, value:)
-      options = {field_type: "#{type}Field",
-                 field_key: config["#{type.to_s.pluralize}_fields"][field],
-                 return_item_ids: true}
+    # Returns an array of Response objects or throws a ResourceNotFoundError if
+    # it couldn't find anything.
+    def search_by_field(field:, value:)
+      query = {field_type: "#{resource}Field",
+               field_key: Config.field_id(resource, field),
+               return_item_ids: true,
+               term: value
+      }
 
-      get("/searchResults/field", options.merge(term: value))
+      response_from self.class.get("/searchResults/field", options(query: query))
     end
 
-    def get(uri, query = {})
-      result_from self.class.get(uri, options(query: query))
+    # Public: Pipedrive GET API call - does a GET request to the Pipedrive API
+    # based on the resource passed in the initialiser
+    #
+    # id - If the resource being searched for has an id
+    # query - An optional query string
+    # start - The offset with which to start the query
+    #
+    # As long as "request_all_pages" is not set to false in the config this will
+    # recursively call `#get` until all the pages of the request have been
+    # fetched from pipedrive
+    # Pipedrive until everything available has been received
+    def get(id = nil, query = {})
+      _get(id, query, get_request(id, query))
     end
 
-    def put(uri, body)
-      result_from self.class.put(uri, options(body: body))
+    def put(id, data)
+      response_from self.class.put(uri(id), options(body: data))
     end
 
-    def post(uri, body)
-      result_from self.class.post(uri, options(body: body))
+    def post(data)
+      response_from self.class.post(uri, options(body: data))
     end
 
     private
 
-    def config
-      Pipekit.config
+    attr_reader :resource
+
+    def _get(id, query, result)
+      return result.response(resource) unless result.fetch_next_request?
+      _get(id, query, result + get_request(id, query, result.next_start))
+    end
+
+    def get_request(id, query, start = 0)
+      response = self.class.get(uri(id), options(query: {limit: pagination_limit, start: start}.merge(query)))
+      Result.new(response)
     end
 
-    def result_from(response)
-      return nil unless success?(response)
-      response.parsed_response["data"]
+    def response_from(response_data)
+      Result.response(resource, response_data)
     end
 
-    def success?(response)
-      response.parsed_response["success"]
+    def uri(id = nil)
+      "/#{resource}s/#{id}".chomp("/")
     end
 
     def options(query: {}, body: {})
       {
-        query: {api_token: config[:api_token] }.merge(query),
-        body: body
+        query: query.merge(api_token: Config.fetch("api_token")),
+        body: parse_body(body)
       }
     end
+
+    # Replaces custom fields with their Pipedrive ID
+    # if the ID is defined in the configuration
+    #
+    # So if the body looked like this with a custom field
+    # called middle_name:
+    #
+    # { middle_name: "Dave" }
+    #
+    # And it has a Pipedrive ID ("123abc"), this will put in this custom ID
+    #
+    # { "123abc": "Dave" }
+    #
+    # meaning you don't have to worry about the custom IDs
+    def parse_body(body)
+      body.reduce({}) do |result, (field, value)|
+        field = Config.field_id(resource, field)
+        value = Config.field_value_id(resource, field, value)
+        result.tap { |result| result[field] = value }
+      end
+    end
+
+    def pagination_limit
+      Config.fetch("pagination_limit", DEFAULT_PAGINATION_LIMIT)
+    end
+
   end
 end

data/lib/pipekit/response.rb

@@ -0,0 +1,122 @@
+module Pipekit
+  class Response
+
+    def initialize(resource, data)
+      @resource = resource
+      @data = data || {}
+    end
+
+    def ==(other)
+      return false unless other.respond_to?(:to_h)
+      to_h == other.to_h
+    end
+
+    def [](key)
+      fetch(key)
+    end
+
+    def to_h
+      data.inject({}) do |result, (field, value)|
+        field_name = Config.field_name(resource, field)
+        result[field_name.to_sym] = Config.field_value(resource, field, value)
+        result
+      end
+    end
+
+    alias_method :to_hash, :to_h
+
+    # This is more complicated than it first seems as Pipedrive returns any
+    # custom field you might create (such as a new cohort in the Cohort field)
+    # as a meaningless Pipedrive ID so it returns something semantically
+    # meaningnless such as "8" when it means "April 2016"
+    #
+    # There are two ways this method gets around this to bring back the
+    # semantically meaningful result you're looking for here, if you put in the
+    # config under "field_values" the IDs that Pipedrive assigns to your custom
+    # values (you'll have to search the API to work out what these are) it will
+    # look them up there.
+    #
+    # Otherwise you can plass the "find_value_on_pipedrive" flag and it will do
+    # a call to the Pipedrive API to look it up. This is off by default as it is
+    # obviously quite slow to call an API each time you want to fetch some data
+    #
+    # Options:
+    #
+    # find_value_on_pipedrive (default: false) - if set to true will look up using the Pipedrive
+    # API the actual value of field (rather than the Pipedrive ID)
+    #
+    # choose_first_value (default: true) - if Pipedrive returns an array of values this will
+    # choose the first one rather than return the array
+    #
+    # Examples:
+    #
+    # Normally you can just use the square brackets alias to fetch responses as
+    # though this was a hash:
+    #
+    #    response[:resource] # returns: "Dave"
+    #
+    # However if you find when doing this Pipedrive returns its meaningless ID
+    #
+    #    response[:cohort] # returns: 1234
+    #
+    # then you can tell Pipedrive to fetch it manually
+    #
+    #    response.fetch(:cohort, find_value_on_pipedrive: true) # returns: "April
+    # 2016"
+    #
+    def fetch(key, default = nil, opts = {})
+      opts = {
+        find_value_on_pipedrive: false,
+        choose_first_value: true
+      }.merge(opts)
+
+      value = fetch_value(key, default)
+
+      return value_from_pipedrive(key.to_s, value) if opts[:find_value_on_pipedrive]
+      convert_value(key, value, opts)
+    end
+
+    def has_key?(key)
+      data.has_key? convert_key(key)
+    end
+
+    private
+
+    attr_reader :data, :resource
+
+    def fetch_value(key, default)
+      data.fetch(convert_key(key), default)
+    end
+
+    def value_from_pipedrive(key, value)
+      return unless value && !value.empty?
+
+      option = field_repository
+        .find_by(name: key)
+        .fetch("options", [], choose_first_value: false)
+        .find { |options| options["id"] == value.to_i }
+
+      raise ResourceNotFoundError.new("Could not find field #{key}'s value '#{value}' on Pipedrive") unless option
+      option.fetch("label")
+    end
+
+    def field_repository
+      Object.const_get("Pipekit::#{resource.capitalize}Field").new
+    end
+
+    def convert_key(key)
+      Config.field_id(resource, key)
+    end
+
+    def convert_value(key, value, opts)
+      value = choose_first(value) if opts[:choose_first_value]
+      Config.field_value(resource, key, value)
+    end
+
+    def choose_first(result)
+      return result unless result.is_a? Array
+      return if result.empty?
+      result.first["value"]
+    end
+  end
+end

data/lib/pipekit/result.rb

@@ -0,0 +1,82 @@
+# Understands how to represent the result of a request to the Pipedrive API
+module Pipekit
+  class Result
+
+    def initialize(response_data)
+      @response_data = response_data
+      raise UnsuccessfulRequestError.new(response_data) unless success?
+    end
+
+    def response(resource)
+      raise ResourceNotFoundError.new(response_data) unless resource_found?
+      return Response.new(resource, response_body) unless response_body.is_a? Array
+      response_body.map { |data| Response.new(resource, data) }
+    end
+
+    def +(other)
+      self.class.new(other.merged_response(response_body))
+    end
+
+    def fetch_next_request?
+      Config.fetch("request_all_pages", true) && pagination_data["more_items_in_collection"]
+    end
+
+    def next_start
+      pagination_data["next_start"]
+    end
+
+    def self.response(resource, response_data)
+      new(response_data).response(resource)
+    end
+
+    protected
+
+    def merged_response(other_body)
+      response_data.tap do |response|
+        response["data"] = other_body + response_body
+      end
+    end
+
+    private
+
+    attr_reader :response_data
+
+    def pagination_data
+      response_data
+        .fetch("additional_data", {})
+        .fetch("pagination", {})
+    end
+
+    def response_body
+      response_data["data"]
+    end
+
+    def success?
+      response_data["success"]
+    end
+
+    def resource_found?
+      !(response_body.nil? || response_body.empty?)
+    end
+  end
+
+  class ResourceNotFoundError < StandardError
+    def initialize(response)
+      @response = response
+    end
+
+    def message
+      "Resource not found: #{@response}"
+    end
+  end
+
+  class UnsuccessfulRequestError < StandardError
+    def initialize(response)
+      @response = response
+    end
+
+    def message
+      "Request not successful: #{@response}"
+    end
+  end
+end

data/lib/pipekit/version.rb

@@ -1,3 +1,3 @@
 module Pipekit
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/pipekit.rb

@@ -1,33 +1,26 @@
-require "pipekit/configurable"
+require "pipekit/config"
 require "httparty"
 require "pipekit/version"
 require "pipekit/request"
+require "pipekit/result"
+require "pipekit/response"
 require "pipekit/repository"
+require "pipekit/field_repository"
 require "pipekit/person"
 require "pipekit/deal"
 require "pipekit/person_field"
+require "pipekit/deal_field"
 require "pipekit/note"
 
 module Pipekit
-  include Configurable
 
   # Define a path to Pipedrive config file
   #
   # Example:
   #
   # Pipekit.config_file_path = File.join("config", "pipedrive.yml")
-  class << self
-    attr_writer :config_file_path
-
-    def config_file_path
-      @config_file_path || raise_config_error
-    end
-
-    def raise_config_error
-      raise ConfigNotSetError, "You need to create a yaml file with your Pipedrive config and set the path to the file using `Pipedrive.config_file_path = 'path/to/file.yml'`"
-    end
+  def self.config_file_path=(path)
+    Config.file_path = path
   end
-
-  ConfigNotSetError = Class.new(Exception)
 end
 

data/pipekit.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Pipedrive API client for Ruby.}
   spec.homepage      = "https://github.com/makersacademy/pipekit"
   spec.license       = "MIT"
+  spec.required_ruby_version = '>= 1.9.1'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
@@ -28,11 +29,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "httparty"
-  spec.add_dependency "activesupport"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "webmock", "~> 2.1.0"
   spec.add_development_dependency "pry"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pipekit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - jafrog
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-29 00:00:00.000000000 Z
+date: 2016-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -26,20 +26,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -86,16 +72,16 @@ dependencies:
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -130,13 +116,17 @@ files:
 - bin/console
 - bin/setup
 - lib/pipekit.rb
-- lib/pipekit/configurable.rb
+- lib/pipekit/config.rb
 - lib/pipekit/deal.rb
+- lib/pipekit/deal_field.rb
+- lib/pipekit/field_repository.rb
 - lib/pipekit/note.rb
 - lib/pipekit/person.rb
 - lib/pipekit/person_field.rb
 - lib/pipekit/repository.rb
 - lib/pipekit/request.rb
+- lib/pipekit/response.rb
+- lib/pipekit/result.rb
 - lib/pipekit/version.rb
 - pipekit.gemspec
 homepage: https://github.com/makersacademy/pipekit
@@ -152,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/pipekit/configurable.rb

@@ -1,46 +0,0 @@
-require "yaml"
-require "active_support/inflector"
-require "active_support/core_ext/hash/indifferent_access"
-
-module Configurable
-  def config
-    self.class.config
-  end
-
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
-
-  module ClassMethods
-    def config_file_path
-      "./config/#{name.underscore}.yml"
-    end
-
-    def config
-      @config ||= load_config.with_indifferent_access
-    end
-
-    private
-
-    def load_config
-      config_hash = load_from_yaml
-
-      config_hash.default_proc = proc do |hash, key|
-        raise Configurable::KeyNotFoundError.new(key)
-      end
-
-      config_hash
-    end
-
-    def load_from_yaml
-      yaml = ERB.new(File.read(config_file_path)).result
-      YAML.load(yaml)
-    end
-  end
-
-  class KeyNotFoundError < StandardError
-    def initialize(key)
-      super("The key #{key} was not found in the configuration file")
-    end
-  end
-end