blockscore 4.0.0 → 4.1.0

data/lib/blockscore/candidate.rb

@@ -0,0 +1,32 @@
+module BlockScore
+  class Candidate < BlockScore::Base
+    extend Forwardable
+
+    include BlockScore::Actions::Create
+    include BlockScore::Actions::Retrieve
+    include BlockScore::Actions::Update
+    include BlockScore::Actions::Delete
+    include BlockScore::Actions::All
+
+    def_delegators 'self.class', :api_url, :endpoint, :get, :post
+
+    def history
+      resource_member 'history'
+    end
+
+    def hits
+      resource_member 'hits'
+    end
+
+    def search(options = {})
+      options[:candidate_id] = id
+      post "#{api_url}watchlists", options
+    end
+
+    private
+
+    def resource_member(member)
+      get "#{endpoint}/#{id}/#{member}", {}
+    end
+  end
+end

data/lib/blockscore/collection.rb

@@ -0,0 +1,12 @@
+module BlockScore
+  class Collection < Array
+    def initialize(target)
+      super()
+      @target = target
+    end
+
+    def method_missing(method, *args, &block)
+      @target.public_send(method, *args, &block)
+    end
+  end
+end

data/lib/blockscore/company.rb

@@ -0,0 +1,7 @@
+module BlockScore
+  class Company < Base
+    include BlockScore::Actions::Create
+    include BlockScore::Actions::Retrieve
+    include BlockScore::Actions::All
+  end
+end

data/lib/blockscore/connection.rb

@@ -0,0 +1,65 @@
+module BlockScore
+  module Connection
+    def get(path, params)
+      request :get, path, params
+    end
+
+    def post(path, params)
+      request(:post, path, params)
+    end
+
+    def patch(path, params)
+      request(:patch, path, params)
+    end
+
+    def put(path, params)
+      request(:put, path, params)
+    end
+
+    def delete(path, params)
+      request(:delete, path, params)
+    end
+
+    private
+
+    def headers
+      @headers ||= {
+        'Accept' => "application/vnd.blockscore+json;version=#{BlockScore::VERSION.to_i}",
+        'User-Agent' => "blockscore-ruby/#{BlockScore::VERSION} (https://github.com/BlockScore/blockscore-ruby)",
+        'Content-Type' => 'application/json'
+      }
+    end
+
+    def request(method, path, params)
+      fail NoAPIKeyError, 'No API key was provided.' unless BlockScore.api_key
+
+      begin
+        response = execute_request(method, path, params)
+      rescue SocketError, Errno::ECONNREFUSED => e
+        fail APIConnectionError, e.message
+      end
+
+      Response.handle_response(resource, response)
+    end
+
+    def execute_request(method, path, params)
+      auth = { :username => BlockScore.api_key, :password => '' }
+
+      if method == :get
+        path = encode_path_params(path, params)
+        params = nil
+      else
+        params = params.to_json
+      end
+
+      options = { :basic_auth => auth, :headers => headers, :body => params }
+
+      HTTParty.send(method, path, options)
+    end
+
+    def encode_path_params(path, params)
+      encoded = URI.encode_www_form(params)
+      [path, encoded].join("?")
+    end
+  end
+end

data/lib/blockscore/dispatch.rb

@@ -0,0 +1,26 @@
+module BlockScore
+  class Dispatch
+    extend Forwardable
+
+    def_delegators :@fingerprint, :builder, :data, :resource
+
+    def initialize(resource, response)
+      @fingerprint = Fingerprint.new(resource, response.body)
+    end
+
+    def call
+      Util.send(builder, resource, data)
+    end
+
+    private
+
+    def builder
+      resource_array? ? :create_array : :create_object
+    end
+
+    # array formatted response
+    def resource_array?
+      data.is_a?(Array)
+    end
+  end
+end

data/lib/blockscore/errors/api_connection_error.rb

@@ -0,0 +1,6 @@
+require 'blockscore/errors/error'
+
+module BlockScore
+  class APIConnectionError < Error
+  end
+end

data/lib/blockscore/errors/api_error.rb

@@ -0,0 +1,33 @@
+module BlockScore
+  class APIError < Error
+    attr_reader :http_status
+    attr_reader :error_type
+    attr_reader :http_body
+
+    # Public: Creates a new instance of BlockScore::Error.
+    #
+    # rbody - The HTTP response body from HTTParty.
+    # rcode - The HTTP response code from HTTParty.
+    #
+    # While BlockScore::Error can be instantiated, the more meaningful
+    # error classes are its subclasses:
+    # InvalidRequestError - Indicates a malformed request (HTTP 400 or 404)
+    # APIError - Indicates an error on the server side (HTTP 5xx)
+    # AuthenticationError - Indicates an authentication error (HTTP 401)
+    def initialize(response)
+      body = JSON.parse(response.body, :symbolize_names => true)
+
+      @message = body[:error][:message]
+      @http_status = response.code
+      @error_type = body[:error][:type]
+      @http_body = body
+    end
+
+    def to_s
+      status_string = @http_status ? "(Status: #{@http_status})" : ""
+      type_string = @error_type ? "(Type: #{@error_type})" : ""
+
+      "#{type_string} #{@message} #{status_string}"
+    end
+  end
+end

data/lib/blockscore/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module BlockScore
+  class AuthenticationError < APIError
+  end
+end

data/lib/blockscore/errors/error.rb

@@ -0,0 +1,4 @@
+module BlockScore
+  class Error < StandardError
+  end
+end

data/lib/blockscore/errors/invalid_request_error.rb

@@ -0,0 +1,29 @@
+module BlockScore
+  class InvalidRequestError < APIError
+    attr_accessor :param
+
+    # Public: Creates a new instance of BlockScore::InvalidRequestError.
+    #
+    # responses - The HTTP response body from HTTParty.
+    #
+    # Examples
+    #
+    # begin
+    #   response = BlockScore::Person.create(...)
+    # rescue BlockScore::InvalidRequestError => e
+    #   puts "ERROR: #{e.message} with code #{e.http_status}"
+    # end
+    def initialize(response)
+      super
+      @param = @http_body[:error][:param]
+    end
+
+    def to_s
+      status_string = @http_status ? "(Status: #{@http_status})" : ""
+      type_string = @error_type ? "(Type: #{@error_type})" : ""
+      param_string = @param ? "(#{@param})" : ""
+
+      "#{type_string} #{@message} #{param_string} #{status_string}"
+    end
+  end
+end

data/lib/blockscore/errors/no_api_key_error.rb

@@ -0,0 +1,4 @@
+module BlockScore
+  class NoAPIKeyError < Error
+  end
+end

data/lib/blockscore/errors/not_found_error.rb

@@ -0,0 +1,4 @@
+module BlockScore
+  class NotFoundError < APIError
+  end
+end

data/lib/blockscore/fingerprint.rb

@@ -0,0 +1,46 @@
+module BlockScore
+  class Fingerprint
+    def initialize(resource, body)
+      @resource = resource
+      @body = Util.parse_json(body)
+    end
+
+    def data
+      @data ||= begin
+        if watchlist_search?
+          body[:matches]
+        elsif resource_index?
+          body[:data]
+        else
+          body
+        end
+      end
+    end
+
+    def resource
+      if watchlist_search? || watchlist_hits?
+        'watchlist_hit'
+      else
+        @resource
+      end
+    end
+
+    private
+
+    attr_reader :body
+
+    # candidates#search endpoint
+    def watchlist_search?
+      body.respond_to?(:key?) && body.key?(:matches)
+    end
+
+    # hash style list format
+    def resource_index?
+      body.is_a?(Hash) && body[:object] == 'list'
+    end
+
+    def watchlist_hits?
+      data.first.is_a?(Hash) && data.first.key?(:matching_info)
+    end
+  end
+end

data/lib/blockscore/person.rb

@@ -0,0 +1,14 @@
+module BlockScore
+  class Person < Base
+    include BlockScore::Actions::Create
+    include BlockScore::Actions::Retrieve
+    include BlockScore::Actions::All
+
+    attr_reader :question_sets
+
+    def initialize(options = {})
+      super
+      @question_sets = Collection.new(QuestionSet.new(:person => self))
+    end
+  end
+end

data/lib/blockscore/question_set.rb

@@ -0,0 +1,26 @@
+module BlockScore
+  class QuestionSet < Base
+    extend Forwardable
+
+    include BlockScore::Actions::Create
+    include BlockScore::Actions::Retrieve
+    include BlockScore::Actions::All
+
+    def_delegators 'self.class', :retrieve, :all, :post, :endpoint
+
+    def create
+      result = self.class.create(:person_id => person.id)
+      person.question_sets << result.id
+
+      result
+    end
+
+    def score(answers = nil)
+      if answers.nil? && attributes
+        attributes[:score]
+      else
+        post "#{endpoint}/#{id}/score", :answers => answers
+      end
+    end
+  end
+end

data/lib/blockscore/response.rb

@@ -0,0 +1,29 @@
+module BlockScore
+  module Response
+    extend self
+
+    def handle_response(resource, response)
+      case response.code
+      when 200, 201
+        Dispatch.new(resource, response).call
+      else
+        api_error(response)
+      end
+    end
+
+    private
+
+    def api_error(response)
+      case response.code
+      when 400
+        fail InvalidRequestError.new(response)
+      when 401
+        fail AuthenticationError.new(response)
+      when 404
+        fail NotFoundError.new(response)
+      else
+        fail APIError.new(response)
+      end
+    end
+  end
+end

data/lib/blockscore/util.rb

@@ -0,0 +1,80 @@
+module BlockScore
+  module Util
+    extend self
+
+    def parse_json!(json_obj)
+      JSON.parse(json_obj, :symbolize_names => true)
+    end
+
+    def parse_json(json_obj)
+      parse_json! json_obj
+    rescue JSON::ParserError
+      fail Error, "An error has occurred. If this problem persists, please message support@blockscore.com."
+    end
+
+    def create_object(resource, options = {})
+      to_constant("BlockScore::#{to_camelcase(resource)}").new(options)
+    end
+
+    def create_array(resource, arr)
+      arr.map { |obj| create_object(resource, obj) }
+    end
+
+    def to_plural(str)
+      if str.end_with? 'y'
+        str[0..-2] + 'ies'
+      elsif str.end_with? 'h'
+        str + 'es'
+      elsif str == 'person'
+        'people'
+      else
+        str + 's'
+      end
+    end
+
+    # Taken from activesupport: http://git.io/vkWtR
+    def to_constant(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+
+    def to_camelcase(str)
+      str.split('_').map { |i| i.capitalize }.join('')
+    end
+
+    # Taken from Rulers: http://git.io/vkWqf
+    def to_underscore(str)
+      str.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+  end
+end