trustly-client-ruby 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c90e99723b00ef20870db739054224a2a736e30a
+  data.tar.gz: d11c19c43749183b921c8278b56572ee29d07ca0
+SHA512:
+  metadata.gz: ac472acbd680ffcdb1696dab28c91031dc70f1f50b1002c4c55854c7c92233703c76597b59a54e1692d36556bfce1087285ec3565d1f767329850de9f2e9b2a4
+  data.tar.gz: 036fd6b47420f61653eaf025cca5f7d4edb20cd020fd31d9f2a414c0f136a66b1deb2e4ea287413de1e0e60d7059ea473101146cd182baa32552cac77d2a1fe3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TODO: Write your name
+
+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,39 @@
+# Trustly::Client::Ruby
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/trustly/client/ruby`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'trustly-client-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install trustly-client-ruby
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/trustly-client-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/trustly.rb

@@ -0,0 +1,3 @@
+module Trustly
+
+end

data/lib/trustly/api.rb

@@ -0,0 +1,108 @@
+
+class Trustly::Api 
+
+  attr_accessor :api_host, :api_port, :api_is_https,:last_request,:trustly_publickey,:trustly_verifyer
+
+  def serialize_data(object)
+    serialized  = ""
+    if object.is_a?(Array)
+      # Its an array 
+      object.each do |obj|
+        serialized.concat(obj.is_a?(Hash) ? serialize_data(obj) : obj.to_s)
+      end
+    elsif object.is_a?(Hash)
+      # Its a Hash
+      object.sort.to_h.each do |key,value|
+        serialized.concat(key.to_s).concat(serialize_data(value))
+      end
+    else
+      # Anything else: numbers, symbols, values
+      serialized.concat object.to_s
+    end
+    return serialized
+  end
+
+  def initialize(host,port,is_https,pem_file)
+    self.api_host     = host
+    self.api_port     = port
+    self.api_is_https = is_https
+
+    self.load_trustly_publickey(pem_file)
+  end
+
+  def load_trustly_publickey(file)
+    self.trustly_publickey = OpenSSL::PKey::RSA.new(File.read(file)) #.public_key
+  end
+
+  def url_path(request=nil)
+    raise NotImplementedError
+  end
+
+  def handle_response(request,httpcall)
+    raise NotImplementedError
+  end
+
+  def insert_credentials(request)
+    raise NotImplementedError
+  end
+
+  protected
+
+  def _verify_trustly_signed_data(method, uuid, signature, data)
+    method        = '' if method.nil?
+    uuid          = '' if uuid.nil?
+    serial_data   = "#{method}#{uuid}#{self.serialize_data(data)}"
+    raw_signature = Base64.decode64(signature)
+    return self.trustly_publickey.public_key.verify(OpenSSL::Digest::SHA1.new, raw_signature, serial_data)
+  end
+
+  def verify_trustly_signed_response(response)
+    method    = response.get_method()
+    uuid      = response.get_uuid()
+    signature = response.get_signature()
+    data      = response.get_data()
+    return self._verify_trustly_signed_data(method, uuid, signature, data)
+  end
+
+  def verify_trustly_signed_notification(response)
+    method    = response.get_method()
+    uuid      = response.get_uuid()
+    signature = response.get_signature()
+    data      = response.get_data()
+    return self._verify_trustly_signed_data(method, uuid, signature, data)
+  end
+
+  def set_host(host=nil,port=nil,is_https=nil)
+    self.api_host = host          unless host.nil?
+    self.load_trustly_publickey() unless host.nil?
+    self.api_port = port          unless port.nil?
+    self.is_https = is_https      unless is_https.nil?
+  end
+
+  def base_url
+    if self.api_is_https
+      return (self.api_port == 443) ? "https://#{self.api_host}" : "https://#{self.api_host}:#{self.api_port}"
+    else
+      return (self.api_port == 80)  ? "http://#{self.api_host}"  : "http://#{self.api_host}:#{self.api_port}"
+    end
+  end
+
+  def uri(request)
+    return URI("#{self.base_url}#{self.url_path(request)}")
+  end
+
+  def call_rpc(request)
+    self.insert_credentials(request)
+    self.last_request    = request
+    uri                  = self.uri(request)
+    http_req             = Net::HTTP::Post.new(uri.path, initheader = {'Content-Type' =>'application/json'})
+    http_req.body        = request.json()
+    http_res             = Net::HTTP.start(uri.hostname, uri.port,{use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE}) { |http| http.request(http_req) }
+    return self.handle_response(request,http_res)
+  end
+
+
+
+end
+  
+

data/lib/trustly/api/signed.rb

@@ -0,0 +1,117 @@
+class Trustly::Api::Signed < Trustly::Api
+
+  attr_accessor :url_path,:api_username, :api_password, :merchant_privatekey, :is_https
+
+
+  def initialize(_options)
+    options = {
+      :host        => 'test.trustly.com',
+      :port        => 443,
+      :is_https    => true,
+      :private_pem => "#{Rails.root}/certs/trustly/test.acuerdalo.private.pem",
+      :public_pem  => "#{Rails.root}/certs/trustly/test.trustly.public.pem"
+    }.merge(_options)
+
+
+    raise Trustly::Exception::SignatureError, "File '#{options[:private_pem]}' does not exist" unless File.file?(options[:private_pem])
+    raise Trustly::Exception::SignatureError, "File '#{options[:public_pem]}' does not exist"  unless File.file?(options[:public_pem])
+
+    super(options[:host],options[:port],options[:is_https],options[:public_pem])
+
+    self.api_username = options.try(:[],:username)
+    self.api_password = options.try(:[],:password)
+    self.is_https     = options.try(:[],:is_https)
+    self.url_path     = '/api/1'
+
+    raise Trustly::Exception::AuthentificationError, "Username not valid" if self.api_username.nil?
+    raise Trustly::Exception::AuthentificationError, "Password not valid" if self.api_password.nil?
+
+    self.load_merchant_privatekey(options[:private_pem])
+
+  end
+
+  def load_merchant_privatekey(filename)
+    self.merchant_privatekey = OpenSSL::PKey::RSA.new(File.read(filename))
+  end
+
+  def handle_response(request,httpcall)
+    response = Trustly::Data::JSONRPCResponse.new(httpcall)
+    raise   Trustly::Exception::SignatureError,'Incoming message signature is not valid' unless self.verify_trustly_signed_response(response)
+    raise   Trustly::Exception::DataError,     'Incoming response is not related to request. UUID mismatch.' if response.get_uuid() != request.get_uuid()
+    return  response
+  end
+
+  def insert_credentials(request)
+    request.set_data( 'Username' , self.api_username)
+    request.set_data( 'Password' , self.api_password)
+    request.set_param('Signature', self.sign_merchant_request(request))
+  end
+
+  def sign_merchant_request(data)
+    raise Trustly::Exception::SignatureError, 'No private key has been loaded' if self.merchant_privatekey.nil?
+    method      = data.get_method()
+    method      = '' if method.nil?
+    uuid        = data.get_uuid()
+    uuid        = '' if uuid.nil?
+    data        = data.get_data()
+    data        = {} if data.nil?
+
+    serial_data = "#{method}#{uuid}#{self.serialize_data(data)}"
+    sha1hash    = OpenSSL::Digest::SHA1.new
+    signature   = self.merchant_privatekey.sign(sha1hash,serial_data)
+    return Base64.encode64(signature).chop #removes \n
+  end
+
+  def url_path(request=nil)
+    return '/api/1'
+  end
+
+  def call_rpc(request)
+    request.set_uuid(SecureRandom.uuid) if request.get_uuid().nil?
+    return super(request)
+  end
+
+  def void(orderid)
+    request = Trustly::Data::JSONRPCRequest.new('Void',{"OrderID"=>orderid},nil)
+    return self.call_rpc(request)
+  end
+
+  def deposit(_options)
+    options = {
+      "Locale"            => "es_ES",
+      "Country"           => "ES",
+      "Currency"          => "EUR",
+      "SuccessURL"        => "https://www.trustly.com/success",
+      "FailURL"           => "https://www.trustly.com/fail",
+      "NotificationURL"   => "https://test.trustly.com/demo/notifyd_test",
+      "Amount"            => 0
+    }.merge(_options)
+
+    ["Locale","Country","Currency","SuccessURL","FailURL","Amount","NotificationURL","EndUserID","MessageID"].each do |req_attr|
+      raise Trustly::Exception::DataError, "Option not valid '#{req_attr}'" if options.try(:[],req_attr).nil?
+    end
+
+    raise Trustly::Exception::DataError, "Amount is 0" if options["Amount"].nil? || options["Amount"].to_f <= 0.0
+
+    attributes = options.slice(
+      "Locale","Country","Currency",
+      "SuggestedMinAmount","SuggestedMaxAmount","Amount",
+      "Currency","Country","IP",
+      "SuccessURL","FailURL","TemplateURL","URLTarget",
+      "MobilePhone","Firstname","Lastname","NationalIdentificationNumber",
+      "ShopperStatement"
+    )
+
+    data       = options.slice("NotificationURL","EndUserID","MessageID")
+
+    # check required fields
+    request = Trustly::Data::JSONRPCRequest.new('Deposit',data,attributes)
+    return self.call_rpc(request)
+    #options["HoldNotifications"] = "1" unless 
+  end
+
+  def withdraw(_options)
+
+  end
+
+end

data/lib/trustly/data.rb

@@ -0,0 +1,65 @@
+class Trustly::Data
+    
+  attr_accessor :payload
+
+  def initialize
+    self.payload = {}
+  end
+  # Vacuum out all keys being set to Nil in the data to be communicated
+  def vacumm(data)
+    if data.is_a? Array
+      ret = []
+      data.each do |elem|
+        unless elem.nil?
+          v = self.vacumm elem
+          ret.append(v) unless v.nil?
+        end
+      end
+      return nil if ret.length == 0
+      return ret
+    elsif data.is_a? Hash
+      ret = {}
+      data.each do |key,elem|
+        unless elem.nil?
+          v = self.vacumm elem
+          ret[key.to_s] = elem unless v.nil?
+        end
+      end
+      return nil if ret.length == 0
+      return ret
+    else
+      return data
+    end
+  end
+
+  def get(name=nil)
+    return name.nil? ? self.payload.dup : self.payload.try(:[],name) 
+  end
+
+  def get_from(sub,name)
+    return nil if sub.nil? || name.nil? || self.payload.try(:[],sub).nil? || self.payload[sub].try(:[],name).nil?
+    return self.payload[sub][name]
+  end
+
+  def set(name,value)
+    self.payload[name] = value
+    return value
+  end
+
+  def set_in(sub,name,value,parent=nil)
+    return nil if sub.nil? || name.nil?
+    self.payload[sub]       = {}      if self.payload.try(:[],sub).nil?
+    self.payload[sub][name] = value
+  end
+
+  def pop(name)
+    v = self.payload.try(:[],name)
+    delete self.payload[name] unless v.nil?
+    return v
+  end
+
+  def json()
+    self.payload.to_json
+  end
+  
+end

data/lib/trustly/data/jsonrpc_request.rb

@@ -0,0 +1,92 @@
+class Trustly::Data::JSONRPCRequest < Trustly::Data::Request
+
+  def initialize(method=nil,data=nil,attributes=nil)
+
+    if !data.nil? || !attributes.nil?
+      self.payload = {"params"=>{}}
+      unless data.nil?
+        if !data.is_a?(Hash) && !attributes.nil?
+          raise TypeError, "Data must be a Hash if attributes is provided"
+        else
+          self.payload["params"]["Data"] = data
+        end
+      else
+        self.payload["params"]["Data"] = {}
+      end
+
+      self.payload["params"]["Data"]["Attributes"] = attributes unless attributes.nil?
+    end
+
+    self.payload['method']  = method unless method.nil?
+    self.payload['params']  = {}     unless self.get('params')
+    self.payload['version'] = '1.1'
+
+  end
+
+
+  def get_param(name)
+    return self.payload['params'].try(:[],name)
+  end
+
+  def get_data(name=nil)
+    data = self.get_param('Data')
+    return data if name.nil?
+    raise  KeyError, "Not found #{name} in data" if data.nil?
+    return data.dup if name.nil?
+    return data.try(:[],name)
+  end
+
+  def get_attribute(name)
+    data        = self.get_param('Data')
+    if data.nil?
+      attributes  = nil
+    else
+      attributes  = data.try(:[],'Attributes')
+    end
+    raise KeyError, "Not found 'Attributes' in data" if attributes.nil?
+    return attributes.dup if name.nil?
+    return attributes.try(:[],name)
+  end
+
+  def set_param(name,value)
+    self.payload['params'][name] = value
+  end
+
+  def set_data(name,value)
+    unless name.nil?
+      self.payload['params']['Data']       = {} if self.payload['params'].try(:[],'Data').nil?
+      self.payload['params']['Data'][name] = value
+    end
+    return value
+  end
+
+  def set_attributes(name,value)
+    unless name.nil?
+      self.payload['params']['Data']                     = {} if self.payload['params'].try(:[],'Data').nil?
+      self.payload['params']['Data']['Attributes']       = {} if self.payload['params']['Data'].try(:[],'Attributes').nil?
+      self.payload['params']['Data']['Attributes'][name] = value
+    end
+    return value
+  end
+
+  def set_uuid(uuid)
+    return self.set_param('UUID',uuid)
+  end
+
+  def get_uuid
+    return self.get_param('UUID')
+  rescue KeyError => e 
+    return nil
+  end 
+
+  def set_method(method)
+    return self.set('method',method)
+  end
+
+  def get_method()
+    return self.get('method')
+  rescue KeyError => e
+    return nil
+  end
+
+end

data/lib/trustly/data/jsonrpc_response.rb

@@ -0,0 +1,15 @@
+class Trustly::Data::JSONRPCResponse < Trustly::Data::Response
+
+  def initialize(http_response)
+    super(http_response)
+    version = self.get("version")
+    raise Trustly::Exception::JSONRPCVersionError, "JSON RPC Version is not supported" if version != '1.1'
+  end
+
+  def get_data(name=nil)
+    return self.response_result.try(:[],"data") if name.nil?
+    return Trustly::Exception::DataError, "Data not found or key is null" if self.response_result.try(:[],"data").nil? || name.nil?
+    return self.response_result["data"][name]
+  end
+
+end

data/lib/trustly/data/jsonrpcnotificationrequest.rb

@@ -0,0 +1,48 @@
+class Trustly::JSONRPCNotificationRequest < Trustly::Data
+
+  attr_accessor :notification_body, :payload
+
+  def initialize(notification_body)
+    super
+    self.notification_body = notification_body
+    begin
+      self.payload = JSON.parse(self.notification_body)
+    rescue JSON::ParserError => e 
+      raise Trustly::Exception::DataError, e.message
+    end
+
+    raise Trustly::Exception::JSONRPCVersionError, 'JSON RPC Version #{(self.get_version()} is not supported' if self.get_version() != '1.1'
+  end
+
+  def get_version()
+    return self.get('version')
+  end
+
+  def get_method()
+    return self.get('method')
+  end
+
+  def get_uuid()
+    return self.get_params('uuid')
+  end
+
+  def get_signature()
+    return self.get_params('signature')
+  end
+
+  def get_params(name)
+    raise KeyError,"#{name} is not present in params" if name.nil? || self.payload.try(:[],"params").nil? || self.payload["params"].try(:[],name).nil?
+    return self.payload["params"][name]
+  end
+
+  def get_data(name=nil)
+    if name.nil?
+      raise KeyError,"Data not present" if self.payload.try(:[],"params").nil? || self.payload["params"].try(:[],"data").nil?
+      return self.payload["params"]["data"]
+    else
+      raise KeyError,"#{name} is not present in data" if name.nil? || self.payload.try(:[],"params").nil? || self.payload["params"].try(:[],"data").nil? || self.payload["params"]["data"].try(:[],name).nil?
+      return self.payload["params"]["data"][name]
+    end
+  end
+
+end

data/lib/trustly/data/jsonrpcnotificationresponse.rb

@@ -0,0 +1,59 @@
+class Trustly::JSONRPCNotificationResponse < Trustly::Data
+  
+  def initialize(request,success=nil)
+    super
+    uuid   = request.get_uuid()
+    method = request.get_method()
+
+    self.set('version')
+    self.set_result('uuid',uuid)     unless uuid.nil?
+    self.set_result('method',method) unless method.nil?
+    self.set_data('success', (!success.nil? && !success ? 'FAILED' : 'OK' ))
+  end
+
+  def set_result(name,value)
+    return nil if name.nil? || value.nil?
+    self.payload["result"]                = {} if self.payload.try(:[],"result").nil?
+    self.payload["result"][name]          = value
+  end
+
+  def set_data(name,value)
+    return nil if name.nil? || value.nil?
+    self.payload["result"]               = {} if self.payload.try(:[],"result").nil?
+    self.payload["result"]["data"]       = {} if self.payload["result"].try(:[],"data").nil?
+    self.payload["result"]["data"][name] = value
+  end
+
+  def get_result(name)
+    raise KeyError,"#{name} is not present in result" if name.nil? || self.payload.try(:[],"result").nil? || self.payload["result"].try(:[],name).nil?
+    return self.payload["result"][name]
+  end
+
+  def get_data(name=nil)
+    raise KeyError,"#{name} is not present in data" if name.nil? || self.payload.try(:[],"result").nil? || self.payload["result"].try(:[],"data").nil? || self.payload["result"]["data"].try(:[],name).nil?
+    return self.payload["result"]["data"][name]
+  end
+
+  def get_data(name=nil)
+    if name.nil?
+      raise KeyError,"Data not present" if self.payload.try(:[],"result").nil? || self.payload["result"].try(:[],"data").nil?
+      return self.payload["result"]["data"]
+    else
+      raise KeyError,"#{name} is not present in data" if name.nil? || self.payload.try(:[],"result").nil? || self.payload["result"].try(:[],"data").nil? || self.payload["result"]["data"].try(:[],name).nil?
+      return self.payload["result"]["data"][name]
+    end
+  end
+
+  def get_method
+    return self.get_result('method')
+  end
+
+  def get_uuid
+    return self.get_result('uuid')
+  end
+
+  def get_signature
+    return self.get_result('signature')
+  end
+
+end

data/lib/trustly/data/request.rb

@@ -0,0 +1,33 @@
+class Trustly::Data::Request < Trustly::Data
+
+  attr_accessor :method
+
+  def initialize(method=nil,payload=nil)
+    super
+    self.payload = self.vacuum(payload) unless payload.nil?
+    unless method.nil?
+      self.method  = method
+    else
+      self.method  = self.payload.get('method')
+    end
+  end
+
+  def get_method
+    return self.method
+  end
+
+  def set_method(method)
+    self.method = method
+    return method
+  end
+
+  def get_uuid
+    return self.payload.get('uuid')
+  end
+
+  def set_uuid
+    self.set('uuid',uuid)
+    return uuid
+  end
+
+end

data/lib/trustly/data/response.rb

@@ -0,0 +1,80 @@
+class Trustly::Data::Response < Trustly::Data
+  attr_accessor :response_status, :response_reason, :response_body, :response_result
+
+  def initialize(http_response) #called from Net::HTTP.get_response("trustly.com","/api_path") -> returns Net::HTTPResponse 
+    super()
+    self.response_status = http_response.code
+    self.response_reason = http_response.class.name
+    self.response_body   = http_response.body
+    begin
+      self.payload       = JSON.parse(self.response_body)
+    rescue JSON::ParserError => e 
+      if self.response_status != 200
+        raise Trustly::Exception::ConnectionError, "#{self.response_status}: #{self.response_reason} [#{self.response_body}]"
+      else
+        raise Trustly::Exception::DataError, e.message
+      end
+    end
+
+    begin
+      self.response_result = self.get('result')
+    rescue IndexError::KeyError => e
+      self.response_result = nil
+    end
+
+    if self.response_result.nil?
+      begin
+        self.response_result = self.payload["error"]["error"]
+      rescue IndexError::KeyError => e
+      end
+    end
+    raise Trustly::Exception::DataError, "No result or error in response #{self.payload}" if self.response_result.nil?
+  end
+
+  def error?
+    return !self.get('error').nil?
+  rescue IndexError::KeyError => e
+    return false
+  end
+
+  def error_code
+    return nil unless self.error?
+    return self.response_result["data"].try(:[],'code')
+  end
+
+  def error_msg
+    return nil unless self.error?
+    return self.response_result["data"].try(:[],'message')
+  end
+
+  def success?
+    return !self.get('result').nil?
+  rescue IndexError::KeyError => e
+    return false
+  end
+
+  def get_uuid
+    return self.response_result.try(:[],'uuid')
+  end
+
+  def get_method
+    return self.response_result.try(:[],'method')
+  end
+
+  def get_signature
+    return self.response_result.try(:[],"signature")
+  end
+
+  def get_result
+    unless name.nil?
+      if self.response_result.is_a?(Hash)
+        return self.response_result.try(:[],name)
+      else
+        raise StandardError::TypeError, "Result is not a Hash"
+      end
+    else
+      return self.response_result.dup
+    end
+  end
+
+end

data/lib/trustly/exception/authentification_error.rb

@@ -0,0 +1,2 @@
+class Trustly::Exception::AuthentificationError < Exception
+end

data/lib/trustly/exception/connection_error.rb

@@ -0,0 +1,2 @@
+class Trustly::Exception::ConnectionError < Exception
+end

data/lib/trustly/exception/data_error.rb

@@ -0,0 +1,3 @@
+class Trustly::Exception::DataError < Exception
+  
+end

data/lib/trustly/exception/jsonrpc_version_error.rb

@@ -0,0 +1,3 @@
+class Trustly::Exception::JSONRPCVersionError < Exception
+  
+end

data/lib/trustly/exception/signature_error.rb

@@ -0,0 +1,2 @@
+class Trustly::Exception::SignatureError < Exception
+end

data/lib/trustly/version.rb

@@ -0,0 +1,3 @@
+module Trustly
+  VERSION = "0.0.6"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: trustly-client-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Jorge Carretie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Support for Ruby use of trustly API
+email: jorge@carretie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/trustly.rb
+- lib/trustly/api.rb
+- lib/trustly/api/signed.rb
+- lib/trustly/data.rb
+- lib/trustly/data/jsonrpc_request.rb
+- lib/trustly/data/jsonrpc_response.rb
+- lib/trustly/data/jsonrpcnotificationrequest.rb
+- lib/trustly/data/jsonrpcnotificationresponse.rb
+- lib/trustly/data/request.rb
+- lib/trustly/data/response.rb
+- lib/trustly/exception/authentification_error.rb
+- lib/trustly/exception/connection_error.rb
+- lib/trustly/exception/data_error.rb
+- lib/trustly/exception/jsonrpc_version_error.rb
+- lib/trustly/exception/signature_error.rb
+- lib/trustly/version.rb
+homepage: https://github.com/jcarreti/trusty-client-ruby
+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.5
+signing_key: 
+specification_version: 4
+summary: Trustly Client Ruby Support
+test_files: []