finapps 1.0.8 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 190f48c84e9cbfcdc797d8c22188152e93fd465c
-  data.tar.gz: db5d6511e35f37300cf54a53528c12e18a276f8a
+  metadata.gz: a0abfe9b391e46bb0657c3b893f6f26117a20f42
+  data.tar.gz: 5e3764decd46daa480ce291872a10ebf7f7c8871
 SHA512:
-  metadata.gz: 2c6c1292afb1b78387f6e3b45bdcf7e87615d95dedd23e9ecc3a383a512cc35baee77db9b411200372a61663325ffd663a90fcf194a65d21f9823805fe94667b
-  data.tar.gz: 980bd68d963e142304f09af751d5bbc46065ef8e568199f4f019770b8f13a5916a1061cd5e93bc859210d219bb547b76f34702b1b0723454088e921a4219266d
+  metadata.gz: 6378daa1c4cd58c8017b1efd59dd6048fb4baf93ccfbacac82862ab2fcd6880e9418054a4887263ab9106640c091524483acbd2ab5e3cc20e92d761c6ebf6fd4
+  data.tar.gz: 8d5e4a4c45df74feab9d3dbbeeea42c32f43a40feccaf5290dd891373330a66cb9806c067c6cc7e1b09fa114b0b5ef3e1c6cd235782a0975196d6214e540ec7e

data/.gitignore

@@ -1,4 +1,5 @@
 /spec/examples.txt
+coverage/
 *.gem
 .config
 Gemfile.lock
@@ -27,4 +28,3 @@ mkmf.log
 .secret
 .idea/
 /spec/tmp/*
-

data/.rspec

@@ -1,5 +1,4 @@
---drb
---format Fuubar
 --color
 --warnings
 --require spec_helper
+--fail-fast

data/.rubocop.yml

@@ -0,0 +1,102 @@
+AllCops:
+  Exclude:
+    - "bin/**/*"
+
+Rails:
+  Enabled: true
+
+##################### Metrics ##################################
+
+Metrics/AbcSize:
+  # The ABC size is a calculated magnitude, so this number can be a Fixnum or
+  # a Float.
+  Max: 25
+
+# Commonly used screens these days easily fit more than 80 characters.
+Metrics/LineLength:
+  Max: 120
+
+# Too short methods lead to extraction of single-use methods, which can make
+# the code easier to read (by naming things), but can also clutter the class
+Metrics/MethodLength:
+  Max: 20
+
+# No space makes the method definition shorter and differentiates
+# from a regular assignment.
+Style/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: no_space
+
+# We do not need to support Ruby 1.9, so this is good to use.
+Style/SymbolArray:
+  Enabled: true
+
+# Most readable form.
+Style/AlignHash:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+# Mixing the styles looks just silly.
+Style/HashSyntax:
+ EnforcedStyle: ruby19_no_mixed_keys
+
+# String#% is by far the least verbose and only object oriented variant.
+Style/FormatString:
+  EnforcedStyle: percent
+
+Style/CollectionMethods:
+  Enabled: true
+  PreferredMethods:
+    # inject seems more common in the community.
+    reduce: "inject"
+
+# Either allow this style or don't. Marking it as safe with parenthesis
+# is silly. Let's try to live without them for now.
+Style/ParenthesesAroundCondition:
+  AllowSafeAssignment: false
+Lint/AssignmentInCondition:
+  AllowSafeAssignment: false
+
+# A specialized exception class will take one or more arguments and construct the message from it.
+# So both variants make sense.
+Style/RaiseArgs:
+  Enabled: false
+
+# Fail is an alias of raise. Avoid aliases, it's more cognitive load for no gain.
+# The argument that fail should be used to abort the program is wrong too,
+# there's Kernel#abort for that.
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+# Suppressing exceptions can be perfectly fine, and be it to avoid to
+# explicitly type nil into the rescue since that's what you want to return,
+# or suppressing LoadError for optional dependencies
+Lint/HandleExceptions:
+  Enabled: false
+
+Style/SpaceInsideBlockBraces:
+  # The space here provides no real gain in readability while consuming
+  # horizontal space that could be used for a better parameter name.
+  # Also {| differentiates better from a hash than { | does.
+  SpaceBeforeBlockParameters: false
+
+# No trailing space differentiates better from the block:
+# foo} means hash, foo } means block.
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+# Enforcing -> would be nice, but not at the cost of enforcing lambda { } for
+# multiline lambdas.
+Style/Lambda:
+  Enabled: false
+
+# Enforcing the names of variables? To single letter ones? Just no.
+Style/SingleLineBlockParams:
+  Enabled: false
+
+# This is just silly. Calling the argument `other` in all cases makes no sense.
+Style/OpMethod:
+  Enabled: false
+
+# Reset some HoundCI changes back to Rubocop defaults
+Style/DotPosition:
+  EnforcedStyle: leading

data/.ruby-gemset

@@ -1 +1 @@
-finapps
+ruby-client-v2

data/.ruby-version

@@ -1 +1 @@
-ruby-2.2.2
+ruby-2.3.1

data/Rakefile

@@ -1 +1 @@
-import './lib/tasks/releaser.rake'
+import './lib/tasks/releaser.rake'

data/finapps.gemspec

@@ -10,27 +10,27 @@ Gem::Specification.new do |spec|
   spec.authors = ['Erich Quintero']
   spec.email = ['erich@financialapps.com']
 
-  spec.summary = %q{FinApps REST API ruby client.}
-  spec.description = %q{A simple library for communicating with the FinApps REST API.}
-  spec.homepage = 'http://github.com/finapps/finapps-ruby'
+  spec.summary = 'FinApps REST API ruby client.'
+  spec.description = 'A simple library for communicating with the FinApps REST API.'
+  spec.homepage = 'https://github.com/finapps/ruby-client'
   spec.license = 'MIT'
 
   spec.files = `git ls-files -z`.split("\x0")
-  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables = spec.files.grep(%r{^bin/}) {|f| File.basename(f) }
   spec.test_files = Dir['spec/**/*.rb']
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'faraday',  '~> 0.9', '>= 0.9.2'
-  spec.add_runtime_dependency 'faraday_middleware',  '~> 0.10', '>= 0.10.0'
-  spec.add_runtime_dependency 'typhoeus',  '~> 1.0', '>= 1.0.1'
+  spec.add_runtime_dependency 'faraday', '~> 0.9', '>= 0.9.2'
+  spec.add_runtime_dependency 'faraday_middleware', '~> 0.10', '>= 0.10.0'
+  spec.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.2'
   spec.add_runtime_dependency 'rash', '~> 0.4', '>= 0.4.0'
 
   spec.add_development_dependency 'bundler', '~> 1.11', '>= 1.11.2'
-  spec.add_development_dependency 'rake', '~> 11.1', '>= 11.1.2'
-  spec.add_development_dependency 'fuubar', '~> 2.0', '>= 2.0.0'
+  spec.add_development_dependency 'rake', '~> 11.2', '>= 11.2.2'
   spec.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
-  spec.add_development_dependency 'webmock', '~> 1.24', '>= 1.24.2'
+  spec.add_development_dependency 'webmock', '~> 2.1', '>= 2.1.0'
   spec.add_development_dependency 'sinatra', '~> 1.4', '>= 1.4.7'
+  spec.add_development_dependency 'simplecov', '~> 0.11', '>= 0.11.2'
 
   spec.extra_rdoc_files = %w(README.md LICENSE.txt)
   spec.rdoc_options = %w(--line-numbers --inline-source --title finapps-ruby --main README.md)

data/lib/finapps/core_extensions/hash/compact.rb

@@ -0,0 +1,22 @@
+# from rails/activesupport/lib/active_support/core_ext/hash/compact.rb
+
+class Hash # :nodoc:
+  # Returns a hash with non +nil+ values.
+  #
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.compact # => { a: true, b: false}
+  #   hash # => { a: true, b: false, c: nil}
+  #   { c: nil }.compact # => {}
+  def compact
+    select {|_, value| !value.nil? }
+  end
+
+  # Replaces current hash with non +nil+ values.
+  #
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.compact! # => { a: true, b: false}
+  #   hash # => { a: true, b: false}
+  def compact!
+    reject! {|_, value| value.nil? }
+  end
+end

data/lib/finapps/core_extensions/integerable.rb

@@ -0,0 +1,14 @@
+module CoreExtensions
+  # adds an integer? method to any object when used in a class
+  module Integerable
+    refine Object do
+      def integer?
+        Integer(self)
+      rescue
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/finapps/core_extensions/object/blank.rb

@@ -0,0 +1,145 @@
+# from: rails/activesupport/lib/active_support/core_ext/object/blank.rb
+
+class Object # :nodoc:
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   !address || address.empty?
+  #
+  # to
+  #
+  #   address.blank?
+  #
+  # @return [true, false]
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def present?
+    !blank?
+  end
+
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
+  #
+  #    object.present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # becomes
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  # @return [Object]
+  def presence
+    self if present?
+  end
+end
+
+class NilClass # :nodoc:
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class FalseClass # :nodoc:
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class TrueClass # :nodoc:
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Array # :nodoc:
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
+  alias blank? empty?
+end
+
+class Hash # :nodoc:
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
+  alias blank? empty?
+end
+
+class String # :nodoc:
+  BLANK_RE = /\A[[:space:]]*\z/
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
+  def blank?
+    # The regexp that matches blank strings is expensive. For the case of empty
+    # strings we can speed up this method (~3.5x) with an empty? call. The
+    # penalty for the rest of strings is marginal.
+    empty? || self =~ BLANK_RE
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Time #:nodoc:
+  # No Time is blank:
+  #
+  #   Time.now.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

data/lib/finapps/error.rb

@@ -0,0 +1,7 @@
+module FinApps # :nodoc:
+  class Error < StandardError; end
+  class InvalidArgumentsError < Error; end
+  class MissingArgumentsError < Error; end
+
+  %i(InvalidArgumentsError MissingArgumentsError).each {|const| Error.const_set(const, FinApps.const_get(const)) }
+end

data/lib/finapps/hash_constructable.rb

@@ -0,0 +1,9 @@
+module FinApps
+  # when included into any object, allows to initialize public attributes from a hash
+  module HashConstructable
+    def initialize(options_hash={}, defaults=nil)
+      merged_hash = defaults.nil? ? options_hash : defaults.merge(options_hash.compact)
+      merged_hash.each {|k, v| public_send("#{k}=", v) }
+    end
+  end
+end

data/lib/finapps/middleware/raise_error.rb

@@ -0,0 +1,46 @@
+module FinApps
+  module Middleware
+    class RaiseError < Faraday::Response::Middleware # :nodoc:
+      include FinApps::Utils::Loggeable
+
+      CLIENT_ERROR_STATUSES = 400...600
+
+      def on_complete(env)
+        case env[:status]
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          raise Faraday::Error::ConnectionFailed, '407 "Proxy Authentication Required"'
+        when CLIENT_ERROR_STATUSES
+          raise Faraday::Error::ClientError, response_values(env)
+        else
+          # 200..206 Success codes
+          # all good!
+          logger.debug "##{__method__} => Status code: [#{env[:status]}]"
+        end
+      end
+
+      def response_values(env)
+        {
+          status:         env.status,
+          headers:        env.response_headers,
+          body:           env.body,
+          error_messages: error_messages(env.body)
+        }
+      end
+
+      private
+
+      def error_messages(body)
+        return nil unless body.present?
+        body = parse_string(body) if body.is_a?(String)
+        body.is_a?(Hash) ? body['messages'].presence : nil
+      end
+
+      def parse_string(body)
+        ::JSON.parse(body)
+      rescue ::JSON::ParserError
+        logger.error "##{__method__} => Unable to parse JSON response."
+      end
+    end
+  end
+end

data/lib/finapps/middleware/tenant_authentication.rb

@@ -0,0 +1,19 @@
+module FinApps
+  module Middleware
+    # Adds a custom header for tenant level authorization.
+    # If the value for this header already exists, it is not overriden.
+    class TenantAuthentication < Faraday::Middleware
+      KEY = 'X-FinApps-Token'.freeze unless defined? KEY
+
+      def initialize(app, options={})
+        super(app)
+        @header_value = "#{options[:identifier].strip}=#{options[:token].strip}"
+      end
+
+      def call(env)
+        env[:request_headers][KEY] ||= @header_value
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/finapps/rest/base_client.rb

@@ -0,0 +1,96 @@
+module FinApps
+  module REST
+    class BaseClient # :nodoc:
+      include ::FinApps::Utils::Loggeable
+
+      attr_reader :config
+
+      def initialize(options={}, logger=nil)
+        @config = FinApps::REST::Configuration.new options
+        @logger = logger
+      end
+
+      # Returns an initialized Faraday connection object.
+      #
+      # @return Faraday::Connection.
+      def connection
+        @connection ||= FinApps::REST::Connection.faraday(config, logger)
+      end
+
+      # Performs HTTP GET, POST, UPDATE and DELETE requests.
+      # You shouldn't need to use this method directly, but it can be useful for debugging.
+      # Returns a hash obtained from parsing the JSON object in the response body.
+      #
+      # @param [String] path
+      # @param [String] method
+      # @param [Hash] params
+      # @return [Hash,Array<String>]
+      def send_request(path, method, params={})
+        raise FinApps::MissingArgumentsError.new 'Missing argument: path.' if path.blank?
+        raise FinApps::MissingArgumentsError.new 'Missing argument: method.' if method.blank?
+
+        response, error_messages = execute_request(method, params, path)
+        result = if response.present?
+                   block_given? ? yield(response) : response.body
+                 else
+                   logger.error "##{__method__} => Null response found. Unable to process it."
+                   nil
+                 end
+
+        [result, error_messages]
+      end
+
+      private
+
+      def execute_request(method, params, path)
+        error_messages = []
+
+        begin
+          response = execute_method method, params, path
+        rescue FinApps::InvalidArgumentsError,
+               FinApps::MissingArgumentsError,
+               Faraday::Error::ConnectionFailed => error
+          logger.fatal "##{__method__} => #{error}"
+          raise error
+        rescue Faraday::Error::ClientError => error
+          error_messages = error.response[:error_messages].blank? ? [error.message] : error.response[:error_messages]
+          logger.error "##{__method__} => Faraday::Error::ClientError, #{error}"
+        rescue StandardError => error
+          error_messages << 'Unexpected error.'
+          logger.fatal "##{__method__} => StandardError, #{error}"
+        end
+
+        [response, error_messages]
+      end
+
+      def execute_method(method, params, path)
+        case method
+        when :get
+          get(path)
+        when :post
+          post(path, params)
+        when :put
+          put(path, params)
+        when :delete
+          delete(path, params)
+        else
+          raise FinApps::InvalidArgumentsError.new "Method not supported: #{method}."
+        end
+      end
+
+      # Defines methods to perform HTTP GET, POST, PUT and DELETE requests.
+      # Returns a hash obtained from parsing the JSON object in the response body.
+      #
+      def method_missing(method_id, *arguments, &block)
+        if %i(get post put delete).include? method_id
+          connection.send(method_id) do |req|
+            req.url arguments.first
+            req.body = arguments[1] unless method_id == :get
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end