finix 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0e8ae111ff460e0564223a26c61921e2bd835d6
+  data.tar.gz: 3a5b69d952123b1b18bceeb8b5a2079b1807d47b
+SHA512:
+  metadata.gz: 117ba294a0bd85a1ba0e21f608950be0601bbf7260d020b16a7bfec473dc4b4e143df522433a2451166ca19bd0f6d9c2e55bad1fcdd889154f4541c5dc6f9671
+  data.tar.gz: 2d021614c589cc51e93998bc2cfb6109a7d2bd18d165d3a57f92b4eca0cdaadf0483e5bf8d70c28bd37acdff3408141a8189ee318e35308a529720328d8fb74b

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+.idea/
+*.gem
+.html/

data/.ruby-gemset

@@ -0,0 +1 @@
+finix

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.5

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in processing-ruby.gemspec
+gemspec
+
+gem 'faraday'
+gem 'faraday_middleware'
+gem 'addressable'
+gem 'json'
+
+group :test do
+  gem 'minitest'
+  gem 'minitest-reporters'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Finix Payments, Inc.
+
+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,6 @@
+# processing-ruby
+
+[![CircleCI](https://circleci.com/gh/finix-payments/processing-ruby.svg?style=svg&circle-token=326db95733638463152e926a1016ec0383e554d2)](https://circleci.com/gh/finix-payments/processing-ruby)
+
+## Getting Started
+`gem install finix`

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+desc 'Run test suite'
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/test_*.rb']
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'finix'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,18 @@
+machine:
+  ruby:
+    version: 2.1.5
+
+  environment:
+    PROCESSING_URL: https://api-staging.finix.io/
+
+dependencies:
+  override:
+    - gem install bundler
+    - bundle install
+
+test:
+  override:
+    - rake test
+
+  post:
+      - cp -Rf .report $CIRCLE_ARTIFACTS

data/finix.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'finix/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'finix'
+  spec.version       = Finix::VERSION
+  spec.authors       = ['finix-payments']
+  spec.email         = ['support@finixpayments.com']
+
+  spec.summary       = %q{Finix Ruby Client}
+  spec.description   = %q{Finix Ruby Client}
+  spec.homepage      = 'https://www.finixpayments.com'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.add_dependency('faraday', ['>= 0.8.6', '<= 0.9.0'])
+  spec.add_dependency('faraday_middleware', '~> 0.9.0')
+  spec.add_dependency('addressable', '~> 2.3.5')
+end

data/lib/finix.rb

@@ -0,0 +1,66 @@
+require 'finix/version' unless defined? Finix::VERSION
+
+module Finix
+
+  @client = nil
+  @config = {:root_url=>'https://localhost/processing'}
+  @hypermedia_registry = {}
+
+  class << self
+
+    attr_accessor :client
+    attr_accessor :config
+    attr_accessor :hypermedia_registry
+
+    def configure(options={})
+      unless options[:root_url].nil? # reset us/pass as well if user update :root_url
+        @config = {}
+      end
+
+      @config = @config.merge(options)
+      @config[:user] = @config[:user].strip unless @config[:user].nil?
+      @config[:password] = @config[:password].strip unless @config[:password].nil?
+
+      @client = Finix::Client.new @config
+    end
+
+    def split_the_href(href)
+      URI.parse(href).path.sub(/\/$/, '').split('/')
+    end
+
+    def from_hypermedia_registry(resource_name)
+      cls = Finix.hypermedia_registry[resource_name]
+      if cls.nil?
+        return Finix::UnknownResource
+      end
+      cls
+    end
+
+    def from_href(href)
+      split_uri = split_the_href(href)
+      split_uri.reverse!.each do |resource|
+        cls = Finix.hypermedia_registry[resource]
+        return cls unless cls.nil?
+      end
+    end
+
+    def is_collection(href)
+      split_uri = split_the_href(href)
+      Finix.hypermedia_registry.has_key?(split_uri.last)
+    end
+
+    def get(*args, &block)
+      self.client.get *args
+    end
+
+    def post(*args, &block)
+      self.client.post *args
+    end
+
+    def put(*args, &block)
+      self.client.put *args
+    end
+  end
+end
+
+require 'finix/resources'

data/lib/finix/client.rb

@@ -0,0 +1,88 @@
+require 'logger'
+require 'uri'
+require 'faraday'
+require 'faraday_middleware'
+require 'finix/response/finix_error_middleware'
+
+
+module Finix
+  class Client
+
+    DEFAULTS = {
+      :logging_level => 'WARN',
+      :connection_timeout => 60,
+      :read_timeout => 60,
+      :logger => nil,
+      :ssl_verify => true,
+      :faraday_adapter => Faraday.default_adapter,
+    }
+
+    attr_reader :conn
+    attr_accessor :config
+
+    def initialize(options={})
+      @config = DEFAULTS.merge options
+      build_conn
+    end
+
+    def build_conn
+      if config[:logger]
+        logger = config[:logger]
+      else
+        logger = Logger.new(STDOUT)
+        logger.level = Logger.const_get(config[:logging_level].to_s)
+      end
+
+      Faraday::Response.register_middleware :handle_api_errors => lambda { Faraday::Response::RaiseApiError }
+
+      options = {
+        :request => {
+          :open_timeout => config[:connection_timeout],
+          :timeout => config[:read_timeout]
+        },
+        :ssl => {
+          :verify => @config[:ssl_verify] # Only set this to false for testing
+        }
+      }
+      @conn = Faraday.new(@config[:url], options) do |cxn|
+        cxn.request :multipart
+        cxn.request :url_encoded
+        cxn.request :json
+        cxn.response :logger, logger
+        cxn.response :handle_api_errors
+        cxn.response :json
+        cxn.adapter  config[:faraday_adapter]
+      end
+      conn.headers['User-Agent'] = "finix-ruby/#{Finix::VERSION}"
+    end
+
+    def method_missing(method, *args, &block)
+      href_or_uri = args[0]
+      args[0] = "#{@config[:root_url]}/#{href_or_uri}" unless href_or_uri =~ /\A#{URI::regexp(%w(http https))}\z/
+      if is_http_method? method
+        # TODO use auth property
+        conn.basic_auth(@config[:user], @config[:password]) unless @config[:user].nil? and @config[:password].nil?
+        conn.send method, *args do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.headers['Content-Type']  = 'multipart/form-data' if ((not req.body.nil?) and req.body.key?('file'))
+        end
+      else
+        super method, *args, &block
+      end
+    end
+
+    private
+
+    def is_http_method? method
+      [:get, :post, :put, :delete].include? method
+    end
+
+    def respond_to?(method, include_private = false)
+      if is_http_method? method
+        true
+      else
+        super method, include_private
+      end
+    end
+  end
+end

data/lib/finix/error.rb

@@ -0,0 +1,33 @@
+module Finix
+
+  class ResourceErrors < ::StandardError
+    attr_reader :response
+    attr_reader :errors
+
+    def initialize(response=nil)
+      @response = response
+      @errors = []
+      @response[:body]['_embedded']['errors'].each { |error| @errors.push Finix::ResourceError.new error}
+    end
+
+    def to_s
+      "#{@errors}"
+    end
+  end
+
+  class ResourceError
+    attr_reader :attributes
+
+    def initialize(error = {})
+      @attributes = {}
+      @attributes = @attributes.merge error
+    end
+  end
+
+  class BadRequest < ResourceErrors; end
+  class Unauthorized < ResourceErrors; end
+  class Forbidden < ResourceErrors; end
+  class NotFound < ResourceErrors; end
+  class MethodNotAllowed < ResourceErrors; end
+  class UnprocessableEntity < ResourceErrors; end
+end

data/lib/finix/hal_resource.rb

@@ -0,0 +1,39 @@
+module Finix
+  module HalResource
+
+    attr_accessor :hyperlinks
+    attr_accessor :attributes
+
+    def method_missing(method, *args, &block)
+      if @attributes.has_key?(method.to_s)
+        return @attributes[method.to_s]
+      end
+
+      case method.to_s
+        when /(.+)=$/
+          attr = method.to_s.chop
+          @attributes[attr] = args[0]
+        else
+          if @hyperlinks.has_key? "#{method}"
+            value = @hyperlinks["#{method}"]
+            result = value.call
+            return result
+          end
+      end
+    end
+
+    if RUBY_VERSION < '1.9'
+      def respond_to?(method_name, include_private=false)
+        does_resource_respond_to?(method_name) || super
+      end
+    else
+      def respond_to_missing?(method_name, include_private=false)
+        does_resource_respond_to?(method_name) || super
+      end
+    end
+
+    def does_resource_respond_to?(method_name)
+      @attributes.has_key?(method_name.to_s) or @hyperlinks.has_key?(method_name.to_s)
+    end
+  end
+end

data/lib/finix/pagination.rb

@@ -0,0 +1,78 @@
+require 'cgi'
+require_relative 'hal_resource'
+
+module Finix
+  class Pagination
+
+    include Enumerable
+    include HalResource
+
+    attr_accessor :resource_class
+
+    def initialize(href, opts={})
+      @hyperlinks = {}
+      @attributes = {}
+
+      @hyperlinks[:self] = href
+      @resource_class = nil
+    end
+
+    def each
+      return enum_for :each unless block_given?
+      current
+      loop do
+        items.each { |item| yield item }
+        fetch :next
+      end
+    end
+
+    def current
+      refresh unless items
+      items
+    end
+
+    def fetch(scope) # :next, :last, :first, :prev, :self
+      scope = scope.to_s.to_sym
+      if @hyperlinks[scope]
+        load_from @hyperlinks[scope]
+        return self.items
+      end
+
+      raise StopIteration
+    end
+
+    def refresh
+      fetch :self
+    end
+
+    def create(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      attrs = Finix::Utils.indifferent_read_access attrs
+      href = @hyperlinks[:self]
+      if @resource_class.nil?
+        @resource_class = Finix.from_href(href)
+      end
+      @resource_class.new(attrs, href).save
+    end
+
+    private
+
+    def load_from(url, params = {})
+      params ||= {}
+
+      response = Finix.get url, params
+      body = Finix::Utils.indifferent_read_access response.body
+
+      links = body.delete('_links')
+      links.each { |key, link| @hyperlinks[key.to_sym] = link[:href] }
+
+      @attributes = {} # clear attributes
+      if body.has_key? '_embedded'
+        resource_name, resources = body.delete('_embedded').first
+        @resource_class = Finix.from_hypermedia_registry resource_name
+        @attributes['items'] = resources.map { |item| @resource_class.construct_from_response item }
+      end
+    end
+
+  end
+end

data/lib/finix/resources.rb

@@ -0,0 +1,20 @@
+require 'finix/resources/verifiable'
+require 'finix/resources/resource'
+require 'finix/resources/unknown_resource'
+require 'finix/resources/hypermedia'
+require 'finix/resources/user'
+require 'finix/resources/application'
+require 'finix/resources/identity'
+require 'finix/resources/processor'
+require 'finix/resources/token'
+require 'finix/resources/merchant'
+require 'finix/resources/payment_instrument'
+require 'finix/resources/payment_card'
+require 'finix/resources/bank_account'
+require 'finix/resources/transfer'
+require 'finix/resources/authorization'
+require 'finix/resources/webhook'
+require 'finix/resources/verification'
+require 'finix/resources/dispute'
+require 'finix/resources/evidence'
+require 'finix/resources/refund'

data/lib/finix/resources/application.rb

@@ -0,0 +1,23 @@
+module Finix
+  class Application
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:applications]
+
+    def create_partner_user(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      self.users.create(attrs)
+    end
+
+    def create_processor(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      self.processors.create(attrs)
+    end
+
+    def create_token(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      self.tokens.create(attrs)
+    end
+  end
+end

data/lib/finix/resources/authorization.rb

@@ -0,0 +1,18 @@
+module Finix
+  class Authorization
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:authorizations]
+
+    def void
+      self['void_me'] = true
+      self.save
+    end
+
+    def capture(attrs={})
+      self.attributes = self.attributes.merge attrs
+      self.save
+    end
+  end
+end

data/lib/finix/resources/bank_account.rb

@@ -0,0 +1,9 @@
+module Finix
+  class BankAccount < PaymentInstrument
+
+    def initialize(attributes = {}, self_href = nil)
+      super(attributes, self_href)
+      self.type = 'BANK_ACCOUNT'
+    end
+  end
+end

data/lib/finix/resources/dispute.rb

@@ -0,0 +1,14 @@
+module Finix
+  class Dispute
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:disputes]
+
+    def upload_evidence(evidence_file_path)
+      # self.evidence.file =  Faraday::UploadIO.new(evidence_file_path, 'application/octet-stream')
+      # self.evidence.file =  Faraday::UploadIO.new(evidence_file_path, 'application/octet-stream')
+      self.evidence.create :file => Faraday::UploadIO.new(evidence_file_path, 'application/octet-stream')
+    end
+  end
+end

data/lib/finix/resources/evidence.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Evidence
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:evidence]
+  end
+end

data/lib/finix/resources/hypermedia.rb

@@ -0,0 +1,26 @@
+module Finix
+
+  module HypermediaRegistry
+
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def define_hypermedia_types(types)
+        @hypermedia_types = types.map! do |t|
+          t.to_s
+        end.sort!.freeze
+
+        @hypermedia_types.each do |type|
+          Finix.hypermedia_registry[type] = self
+        end
+      end
+
+      attr_reader :hypermedia_types
+    end
+
+  end
+
+end

data/lib/finix/resources/identity.rb

@@ -0,0 +1,36 @@
+module Finix
+  class Identity
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+    include Finix::Verifiable
+
+    define_hypermedia_types [:identities]
+
+    def provision_merchant_on(attrs={})
+      self.merchants.create(attrs)
+    end
+
+    def create_payment_instrument(attrs={})
+      if attrs.is_a?(Finix::Resource)
+        attrs.identity = self.id
+        attrs = attrs.attributes
+      else
+        attrs['identity'] = self.id # TODO might be error here
+      end
+
+      if attrs['type'] == 'PAYMENT_CARD'
+        self.payment_instruments.resource_class = Finix::PaymentCard
+      elsif attrs['type'] == 'BANK_ACCOUNT'
+        self.payment_instruments.resource_class = Finix::BankAccount
+      end
+
+      self.payment_instruments.create(attrs)
+    end
+
+    def create_settlement(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      self.settlements.create(attrs)
+    end
+
+  end
+end

data/lib/finix/resources/merchant.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Merchant
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:merchants]
+  end
+end

data/lib/finix/resources/payment_card.rb

@@ -0,0 +1,9 @@
+module Finix
+  class PaymentCard < PaymentInstrument
+
+    def initialize(attributes = {}, self_href = nil)
+      super(attributes, self_href)
+      self.type = 'PAYMENT_CARD'
+    end
+  end
+end

data/lib/finix/resources/payment_instrument.rb

@@ -0,0 +1,8 @@
+module Finix
+  class PaymentInstrument
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:payment_instruments]
+  end
+end

data/lib/finix/resources/processor.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Processor
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:processors]
+  end
+end

data/lib/finix/resources/refund.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Refund
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:reversals]
+  end
+end

data/lib/finix/resources/resource.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../../pagination', __FILE__)
+require File.expand_path('../../utils', __FILE__)
+require File.expand_path('../../hal_resource', __FILE__)
+require 'addressable/template'
+
+module Finix
+
+  module Resource
+
+    include HalResource
+
+    def initialize(attributes = {}, href = nil)
+      @attributes = Utils.indifferent_read_access attributes
+
+      @hyperlinks = {}
+      @hyperlinks[:self] = href if href =~ URI::regexp
+    end
+
+    def hydrate(links)
+      links.each do |key, link|
+        property = key.sub(/.*?\./, '')
+
+        if property == 'self'
+          @hyperlinks[:self] = link[:href]
+          # @attributes['href'] = link[:href]
+        else
+          @hyperlinks[property] = Finix::Utils.callable(Finix::Pagination.new(link[:href], {}))
+          # @hyperlinks[property] = Finix.from_hypermedia_registry(property).new 'href' => link[:href]
+        end
+      end
+    end
+
+    def fetch(*arguments)
+      self.class.find *arguments
+    end
+
+    alias find fetch
+
+    def save(options = {}, href = nil)
+      options = options.is_a?(Finix::Resource) ? options.attributes : options
+      @attributes = @attributes.merge options
+      href ||= @hyperlinks[:self]
+      # href = @attributes.delete('href')
+      method = :post
+      if href.nil?
+        href = Finix.hypermedia_registry.key(self.class)
+      elsif not @attributes[:id].nil?
+        method = :put
+      end
+
+      attributes_to_submit = self.sanitize
+      begin
+        @response = Finix.send(method, href, attributes_to_submit)
+      rescue Exception
+        raise
+      end
+
+      refresh @response
+    end
+
+    def sanitize
+      to_submit = {}
+      @attributes.each do |key, value|
+        if not value.is_a? Finix::Resource
+          to_submit[key] = value
+        end
+      end
+      to_submit
+    end
+
+    def response
+      @response
+    end
+
+    private :response
+
+    def refresh(the_response = nil)
+      if the_response
+        return if the_response.body.to_s.length.zero?
+        fresh = self.class.construct_from_response the_response.body
+      else
+        fresh = self.find(@hyperlinks[:self])
+        # fresh = self.find(@attributes[:href])
+      end
+      fresh and copy_from fresh
+      self
+    end
+
+    # alias refresh load!
+
+    def copy_from(other)
+      other.instance_variables.each do |ivar|
+        instance_variable_set ivar, other.instance_variable_get(ivar)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def construct_from_response(payload)
+        payload = Finix::Utils.indifferent_read_access payload
+
+        links = payload.delete('_links') || {}
+        instance = self.new payload
+        instance.hydrate(links)
+        instance
+      end
+
+      def fetch(*arguments)
+        if arguments.nil? or arguments.empty? or arguments[0].nil? or arguments[0].to_s.empty? # no symbol.empty? in 1.8.7
+          raise Finix::NotFound
+        end
+
+        options = arguments.slice!(0) or {}
+        if options.is_a? String
+          href = options
+        else
+          href = Finix.hypermedia_registry.key(self) or Finix.hypermedia_registry.key(self.class)
+          id = options.delete(:id)
+          href = "#{href}/#{id}" unless id.nil?
+        end
+
+        response = Finix.get href
+        construct_from_response response.body
+
+      end
+
+      alias find fetch
+
+      # def paginate(options = {})
+      #   Finix::Pagination.new href, options
+      # end
+
+      # alias scoped paginate
+      # alias where paginate
+
+      # def all(options = {})
+      #   pager = paginate(options)
+      #   pager.to_a
+      # end
+
+    end
+
+  end
+end

data/lib/finix/resources/settlement.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Settlement
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:settlements]
+  end
+end

data/lib/finix/resources/token.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Token
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:tokens]
+  end
+end

data/lib/finix/resources/transfer.rb

@@ -0,0 +1,12 @@
+module Finix
+  class Transfer
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:transfers]
+
+    def reverse(refund_amount=0)
+      self.reversals.create :refund_amount => refund_amount
+    end
+  end
+end

data/lib/finix/resources/unknown_resource.rb

@@ -0,0 +1,5 @@
+module Finix
+  class UnknownResource
+    include Finix::Resource
+  end
+end

data/lib/finix/resources/user.rb

@@ -0,0 +1,13 @@
+module Finix
+  class User
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:users]
+
+    def create_application(attrs = {})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      self.applications.create(attrs)
+    end
+  end
+end

data/lib/finix/resources/verifiable.rb

@@ -0,0 +1,12 @@
+module Finix
+  module Verifiable
+    def verify_on(attrs={})
+      attrs = attrs.attributes if attrs.is_a?(Finix::Resource)
+      unless self.verifications.nil?
+        self.verifications.create(attrs)
+      else
+        raise 'Unsupported Method'
+      end
+    end
+  end
+end

data/lib/finix/resources/verification.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Verification
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:verifications]
+  end
+end

data/lib/finix/resources/webhook.rb

@@ -0,0 +1,8 @@
+module Finix
+  class Webhook
+    include Finix::Resource
+    include Finix::HypermediaRegistry
+
+    define_hypermedia_types [:webhooks]
+  end
+end

data/lib/finix/response/finix_error_middleware.rb

@@ -0,0 +1,26 @@
+require 'faraday'
+require 'finix/error'
+
+module Faraday
+
+  class Response::RaiseApiError < Response::Middleware
+
+    HTTP_STATUS_CODES = {
+        400 => Finix::BadRequest,
+        401 => Finix::Unauthorized,
+        403 => Finix::Forbidden,
+        404 => Finix::NotFound,
+        405 => Finix::MethodNotAllowed,
+        422 => Finix::UnprocessableEntity
+    }
+
+    def on_complete(response)
+      status_code = response[:status].to_i
+      error_class = HTTP_STATUS_CODES[status_code]
+      raise Finix::ResourceErrors.new(response) if error_class.nil? and status_code >= 400
+      raise error_class.new(response) if error_class
+    end
+
+  end
+
+end

data/lib/finix/utils.rb

@@ -0,0 +1,108 @@
+module Finix
+
+  module Utils
+
+    def callable(callable_or_not)
+      callable_or_not.respond_to?(:call) ? callable_or_not : lambda { callable_or_not }
+    end
+
+    def camelize(underscored_word)
+      underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def classify(table_name)
+      camelize singularize(table_name.to_s.sub(/.*\./, ''))
+    end
+
+    def demodulize(class_name_in_module)
+      class_name_in_module.to_s.sub(/^.*::/, '')
+    end
+
+    def pluralize(word)
+      word.to_s.sub(/([^s])$/, '\1s')
+    end
+
+    def singularize(word)
+      word.to_s.sub(/s$/, '').sub(/ie$/, 'y')
+    end
+
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr! '-', '_'
+      word.downcase!
+      word
+    end
+
+    # def extract_href_from_object(object)
+    #   object.respond_to?(:href) ? object.href : object
+    # end
+
+    def indifferent_read_access(base = {})
+      indifferent = Hash.new do |hash, key|
+        hash[key.to_s] if key.is_a? Symbol
+      end
+      base.each_pair do |key, value|
+        if value.is_a? Hash
+          value = indifferent_read_access value
+        elsif value.respond_to? :each
+          if value.respond_to? :map!
+            value.map! do |v|
+              if v.is_a? Hash
+                v = indifferent_read_access v
+              end
+              v
+            end
+          else
+            value.map do |v|
+              if v.is_a? Hash
+                v = indifferent_read_access v
+              end
+              v
+            end
+          end
+        end
+        indifferent[key.to_s] = value
+      end
+      indifferent
+    end
+
+    # def stringify_keys!(hash)
+    #   hash.keys.each do |key|
+    #     stringify_keys! hash[key] if hash[key].is_a? Hash
+    #     hash[key.to_s] = hash.delete key if key.is_a? Symbol
+    #   end
+    # end
+
+    # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+    # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+    # as keys, this will fail.
+    #
+    # ==== Examples
+    #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+    #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+    #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+    # def assert_valid_keys(hash, *valid_keys)
+    #   unknown_keys = hash.keys - [valid_keys].flatten
+    #   raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(', ')}") unless unknown_keys.empty?
+    # end
+
+    # http://pablomanrubia.com/2011/03/extending-ruby-to-validate-required-keys-in-a-hash-table/
+    #def assert_required_keys(hash, params)
+    #  params[:required] ||= []
+    #  params[:optional] ||= []
+    #  assert_valid_keys(hash, params[:required] + params[:optional])
+    #  pending_keys = params[:required] - hash.keys
+    #  raise(ArgumentError, "Required key(s) not present: #{pending_keys.join(', ')}") unless pending_keys.empty?
+    #end
+
+    # def assert_required_keys(hash, params)
+    #   params[:required] ||= []
+    #   pending_keys = params[:required] - hash.keys
+    #   raise(ArgumentError, "Required key(s) not present: #{pending_keys.join(', ')}") unless pending_keys.empty?
+    # end
+    extend self
+  end
+end

data/lib/finix/version.rb

@@ -0,0 +1,3 @@
+module Finix
+  VERSION = '0.2'
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: finix
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- finix-payments
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+description: Finix Ruby Client
+email:
+- support@finixpayments.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- finix.gemspec
+- lib/finix.rb
+- lib/finix/client.rb
+- lib/finix/error.rb
+- lib/finix/hal_resource.rb
+- lib/finix/pagination.rb
+- lib/finix/resources.rb
+- lib/finix/resources/application.rb
+- lib/finix/resources/authorization.rb
+- lib/finix/resources/bank_account.rb
+- lib/finix/resources/dispute.rb
+- lib/finix/resources/evidence.rb
+- lib/finix/resources/hypermedia.rb
+- lib/finix/resources/identity.rb
+- lib/finix/resources/merchant.rb
+- lib/finix/resources/payment_card.rb
+- lib/finix/resources/payment_instrument.rb
+- lib/finix/resources/processor.rb
+- lib/finix/resources/refund.rb
+- lib/finix/resources/resource.rb
+- lib/finix/resources/settlement.rb
+- lib/finix/resources/token.rb
+- lib/finix/resources/transfer.rb
+- lib/finix/resources/unknown_resource.rb
+- lib/finix/resources/user.rb
+- lib/finix/resources/verifiable.rb
+- lib/finix/resources/verification.rb
+- lib/finix/resources/webhook.rb
+- lib/finix/response/finix_error_middleware.rb
+- lib/finix/utils.rb
+- lib/finix/version.rb
+homepage: https://www.finixpayments.com
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Finix Ruby Client
+test_files: []