judopay 1.0.2.pre → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 690b26307f78ab7d86d45dbf2bc0f1fec0d1a685
-  data.tar.gz: 76f31267f21171e651f091097372dcd76f40c1c3
+  metadata.gz: adc77d2a9f1b25747948b90476f9b72610823d58
+  data.tar.gz: 3747bc655c3d24a90883970037ce3f746f9a115d
 SHA512:
-  metadata.gz: 331a700e95c41ec494a61a49888bf731ceb033688fb4d3721219994ee1f70d8a23c468de15264e3a627fad3c703bc7667a1420bcbb6a4e6bf7a23c528b03599b
-  data.tar.gz: 02ffa1528b30fb99e46b429a6c158e1287b0cb3653b83584abe7bec4d974e1867d7ecc0ca265948e15fc810343f59f380d40e1e31ff9f4c845afacd65b2a2b6b
+  metadata.gz: e75fa57d16570440e16117e37fb6a47fcb9b991c69970009f105efe0224ce225369eb5bcaaeff9f34b37777fe87ac742eba66c40653644385d5a4ab39abdea12
+  data.tar.gz: af7d3f3ce3d06e1cd7942c28fdcfa257f61a9bb759de1be709a15b9e985db30974f86b314d736e6a09c75d607e49bb971f25d4df0b82091dbc0876f82ffbc9d2

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.1.2
+  - 2.0.0
+sudo: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Version 4.0.0
+
+First public release. Numbered to match current version of JudoPay API.

data/README.md

@@ -2,6 +2,8 @@
 
 The Judopay gem supports Ruby 1.9.3 and above (including 2.0.x and 2.1.x).
 
+[![Build Status](https://travis-ci.org/JudoPay/RubySdk.svg?branch=master)](https://travis-ci.org/JudoPay/RubySdk)
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -1,7 +1,22 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'rake/testtask'
 
 RSpec::Core::RakeTask.new
 
-task :default => :spec
-task :test => :spec
+Rake::TestTask.new do |t|
+  raise 'Please setup JUDO_* environment vars' unless ENV['JUDO_API_ID'] && ENV['JUDO_API_TOKEN'] && ENV['JUDO_API_SECRET']
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+task :code_check do
+  sh 'rubocop'
+  Rake::Task['spec'].invoke
+  Rake::Task['test'].invoke
+end
+
+# check code before build
+task :build => :code_check
+task :default => :build

data/judopay.gemspec

@@ -5,7 +5,7 @@ require 'judopay/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'judopay'
-  spec.version       = Judopay::VERSION
+  spec.version       = Judopay::SDK_VERSION
   spec.authors       = ['judoPay']
   spec.email         = ['developersupport@judopay.com']
   spec.summary       = 'Ruby SDK wrapper for the Judopay REST API'
@@ -19,19 +19,20 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 1.9.3'
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'test-unit'
   spec.add_development_dependency 'yard-xml'
   spec.add_development_dependency 'factory_girl'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'webmock'
-  spec.add_dependency 'virtus', '=1.0.2'
-  spec.add_dependency 'httpclient', '=2.4.0'
-  spec.add_dependency 'activemodel', '=4.1.1'
-  spec.add_dependency 'faraday', '=0.9.0'
-  spec.add_dependency 'faraday_middleware', '=0.9.1'
-  spec.add_dependency 'rash', '=0.4.0'
-  spec.add_dependency 'addressable', '=2.3.6'
+  spec.add_dependency 'bundler'
+  spec.add_dependency 'rake'
+  spec.add_dependency 'virtus', '~> 1.0.2'
+  spec.add_dependency 'httpclient', '~> 2.4.0'
+  spec.add_dependency 'activemodel', '~> 4.1.1'
+  spec.add_dependency 'faraday', '~> 0.9.0'
+  spec.add_dependency 'faraday_middleware', '~> 0.9.1'
+  spec.add_dependency 'rash', '~> 0.4.0'
+  spec.add_dependency 'addressable', '~> 2.3.6'
 end

data/lib/faraday/raise_http_exception.rb

@@ -7,24 +7,7 @@ module FaradayMiddleware
   class RaiseHttpException < Faraday::Middleware
     def call(env)
       @app.call(env).on_complete do |response|
-        case response.status.to_i
-        when 400
-          fail Judopay::BadRequest, response
-        when 401, 403
-          fail Judopay::NotAuthorized, response
-        when 404
-          fail Judopay::NotFound, response
-        when 409
-          fail Judopay::Conflict, response
-        when 500
-          fail Judopay::InternalServerError, response
-        when 502
-          fail Judopay::BadGateway, response
-        when 503
-          fail Judopay::ServiceUnavailable, response
-        when 504
-          fail Judopay::GatewayTimeout, response
-        end
+        raise Judopay::APIError.factory(response) unless response.status.to_i == 200
       end
     end
 

data/lib/judopay.rb

@@ -25,15 +25,13 @@ module Judopay
     logger.add(log_level) { message }
   end
 
-  protected
-
   # Based on the use_production flag, which endpoint should we use?
   def self.configure_endpoint_for_environment
-    if self.configuration.use_production == true
-      self.configuration.endpoint_url = self.configuration.api_endpoints[:production]
-    else
-      self.configuration.endpoint_url = self.configuration.api_endpoints[:sandbox]
-    end
+    self.configuration.endpoint_url = if self.configuration.use_production
+                                        self.configuration.api_endpoints[:production]
+                                      else
+                                        self.configuration.api_endpoints[:sandbox]
+                                      end
   end
 
   class Configuration
@@ -52,10 +50,10 @@ module Judopay
 
     # Set sensible configuration defaults
     def initialize
-      @api_version = '4.0.0'
+      @api_version = Judopay::API_VERSION
       @format = 'json'
       @use_production = false
-      @user_agent = 'Judopay Ruby SDK gem v' + Judopay::VERSION
+      @user_agent = "Judopay Ruby (#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}) SDK gem v#{Judopay::SDK_VERSION}"
       @logger = Judopay::NullLogger.new
       @api_endpoints = {
         :sandbox => 'https://partnerapi.judopay-sandbox.com',
@@ -63,5 +61,10 @@ module Judopay
       }.freeze
       @endpoint_url = @api_endpoints[:sandbox]
     end
+
+    def validate
+      return true unless judo_id.to_s.empty? || api_token.to_s.empty? || api_secret.to_s.empty?
+      raise Judopay::ValidationError, 'SDK configuration variables missing'
+    end
   end
 end

data/lib/judopay/connection.rb

@@ -10,31 +10,29 @@ module Judopay
     private
 
     def connection(raw = false)
-      options = {
-        :headers => request_headers,
-        :url => Judopay.configuration.endpoint_url,
-        :ssl => {
-          :ca_file => File.dirname(File.dirname(__FILE__)) + '/certs/rapidssl_ca.crt',
-          :cert_store => false,
-          :verify => true
-        }
-      }
-
-      connection = Faraday::Connection.new(options) do |faraday|
-        faraday.adapter :httpclient
+      connection = Faraday::Connection.new(default_connection_options) do |faraday|
+        # When adapter set to "httpclient" SSL error emerges after bunch of requests:
+        # "Faraday::SSLError: SSL_connect SYSCALL returned=5 errno=0 state=SSLv2/v3 read server hello A"
+        faraday.adapter :net_http
         faraday.use Faraday::Request::UrlEncoded
         faraday.use Faraday::Response::Logger, Judopay.configuration.logger
-        faraday.use FaradayMiddleware::JudoMashify unless raw
-        unless raw
-          case Judopay.configuration.format.to_s
-          when 'json' then faraday.use Faraday::Response::ParseJson
-          end
-        end
+        define_format(faraday, raw)
         faraday.use FaradayMiddleware::RaiseHttpException
       end
 
+      define_auth(connection)
+    end
+
+    def define_format(faraday, raw)
+      return if raw
+      faraday.use FaradayMiddleware::JudoMashify
+      faraday.use Faraday::Response::ParseJson if Judopay.configuration.format.to_s == 'json'
+    end
+
+    def define_auth(connection)
       # Authentication with basic auth if there is no OAuth2 access token
       if Judopay.configuration.oauth_access_token.nil?
+        Judopay.configuration.validate
         connection.basic_auth(
           Judopay.configuration.api_token,
           Judopay.configuration.api_secret
@@ -45,6 +43,18 @@ module Judopay
       connection
     end
 
+    def default_connection_options
+      {
+        :headers => request_headers,
+        :url => Judopay.configuration.endpoint_url,
+        :ssl => {
+          :ca_file => File.dirname(File.dirname(__FILE__)) + '/certs/rapidssl_ca.crt',
+          :cert_store => false,
+          :verify => true
+        }
+      }
+    end
+
     def request_headers
       format = Judopay.configuration.format
 

data/lib/judopay/core_ext/string.rb

@@ -4,7 +4,7 @@ class String
   #   "foo_bar".camel_case          #=> "fooBar"
   def camel_case
     return self if self !~ /_/ && self =~ /[A-Z]+.*/
-    split('_').map { |e| e.capitalize }.join.uncapitalize
+    split('_').map(&:capitalize).join.uncapitalize
   end
 
   # Convert first letter to lower case
@@ -19,8 +19,9 @@ class String
   #
   #   "BananaMan".underscore        #=> "banana_man"
   def underscore
-    to_s.strip
-      .gsub(' ', '_')
+    to_s
+      .strip
+      .tr(' ', '_')
       .gsub(/::/, '/')
       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
       .gsub(/([a-z\d])([A-Z])/, '\1_\2')

data/lib/judopay/error.rb

@@ -1,133 +1,91 @@
 require 'json'
 
 module Judopay
-  # Base error class
-  class Error < StandardError
-    attr_writer :message
-
-    def initialize(message = nil)
+  # Single field error model
+  class FieldError
+    attr_accessor :message, :code, :field_name, :detail
+
+    def initialize(message, code, field_name, detail)
+      @detail = detail
+      @field_name = field_name
+      @code = code
       @message = message
     end
 
-    def message
-      @message || self.class.name
-    end
-
     def to_s
-      @message
+      "Field \"#{@field_name}\" (code #{@code}): #{@message}"
     end
   end
 
   # Custom error class for rescuing from all API errors
   class APIError < StandardError
-    attr_accessor :response, :error_type, :model_errors, :message, :parsed_body
-
-    def initialize(response = nil)
-      @response = response
-
-      # Log the error
-      Judopay.log(Logger::ERROR, self.class.name + ' ' + @message.to_s)
+    CATEGORY_UNKNOWN = 0
+    CATEGORY_REQUEST = 1
+    CATEGORY_MODEL = 2
+    CATEGORY_CONFIG = 3
+    CATEGORY_PROCESSING = 4
+    CATEGORY_EXCEPTION = 5
+
+    attr_accessor :message, :error_code, :status_code, :category, :field_errors
+
+    class << self
+      def factory(response)
+        parsed_body = JSON.parse(response.body)
+
+        new(
+          parsed_body['message'],
+          parsed_body['code'],
+          response.status.to_i,
+          parsed_body['category'],
+          extract_field_errors(parsed_body['details'])
+        )
+      end
 
-      # If we got a JSON response body, set variables
-      return if parsed_body.nil?
+      protected
 
-      @message = body_attribute('errorMessage')
-      @error_type = body_attribute('errorType').to_i
-      api_model_errors = body_attribute('modelErrors')
-      return if api_model_errors.nil?
+      def extract_field_errors(field_errors)
+        result = []
 
-      process_api_model_errors(api_model_errors)
-    end
+        field_errors.to_a.each do |field_error|
+          result << FieldError.new(field_error['message'], field_error['code'], field_error['fieldName'], field_error['detail'])
+        end
 
-    def http_status
-      @response.status.to_i if @response
+        result
+      end
     end
 
-    def http_body
-      @response.body if @response
+    def initialize(message, error_code = 0, status_code = 0, category = CATEGORY_UNKNOWN, field_errors = [])
+      @message = message
+      @error_code = error_code
+      @status_code = status_code
+      @category = category
+      @field_errors = field_errors
     end
 
     def to_s
-      return @message if model_errors.nil?
-
-      summary = []
-      model_errors.each do |_key, value|
-        summary.push(value.join('; '))
-      end
-
-      @message + ' (' + summary.join('; ') + ')'
+      "JudoPay ApiException (status code #{@status_code}, error code #{@error_code}, category #{@category}) #{message}"
     end
 
     def message
-      @message || self.class.name
-    end
-
-    def parsed_body
-      @parsed_body ||= parse_body
+      (@message || self.class.name) + field_errors_message
     end
 
     protected
 
-    def parse_body
-      return unless @response.respond_to?('response_headers')
-      return unless @response.response_headers.include?('Content-Type')
-      return unless @response.response_headers['Content-Type'].include?('application/json')
-
-      ::JSON.parse(@response.body)
-    end
-
-    def body_attribute(attribute)
-      return nil if parsed_body.nil? || !parsed_body.include?(attribute)
-      parsed_body[attribute]
-    end
-
-    # Turn API model errors into a more ActiveRecord-like format
-    def process_api_model_errors(api_model_errors)
-      @model_errors = {}
-      api_model_errors.each do |api_model_error|
-        next unless api_model_error.is_a?(Hash)
-        field_name = api_model_error['fieldName'].underscore.to_sym
-        @model_errors[field_name] = [] if @model_errors[field_name].nil?
-        @model_errors[field_name].push(api_model_error['errorMessage'])
-      end
+    def field_errors_message
+      return '' if @field_errors.empty?
+      "\nFields errors:\n#{@field_errors.join("\n")}"
     end
   end
 
-  # Raised when API returns the HTTP status code 400
-  class BadRequest < APIError; end
-
-  # Raised when API returns the HTTP status code 401/403
-  class NotAuthorized < APIError
-    def message
-      'Authorization has been denied for this request'
-    end
-  end
-
-  # Raised when API returns the HTTP status code 404
-  class NotFound < APIError; end
-
-  # Raised when API returns the HTTP status code 409
-  class Conflict < APIError; end
-
-  # Raised when API returns the HTTP status code 500
-  class InternalServerError < APIError; end
-
-  # Raised when API returns the HTTP status code 502
-  class BadGateway < APIError; end
-
-  # Raised when API returns the HTTP status code 503
-  class ServiceUnavailable < APIError; end
-
-  # Raised when API returns the HTTP status code 504
-  class GatewayTimeout < APIError; end
-
   # A validation error that hasn't reached the API
   class ValidationError < StandardError
     attr_accessor :errors, :message
 
-    def initialize(errors)
+    def initialize(message, errors = nil)
       @errors = errors
-      @message = 'Missing required fields' + model_errors_summary
+      @message = message
+      @message += model_errors_summary unless @errors.nil?
     end
 
     def to_s
@@ -142,12 +100,12 @@ module Judopay
     protected
 
     def model_errors_summary
-      summary = []
+      summary = ["\nField errors:"]
       model_errors.each do |key, value|
-        summary.push(key.to_s + ' ' + value.join('; '))
+        summary.push("#{key}: #{value.join('; ')}")
       end
 
-      ' (' + summary.join('; ') + ')'
+      summary.join("\n")
     end
   end
 end