accepton 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: abcdeaf4b53cb5a1d1fcc6ca936f8d5830a10d43
+  data.tar.gz: df95703326ad1575f6eb93e2530ece5617a79fcd
+SHA512:
+  metadata.gz: bdeb63330e0e3d50c952bef0a68db1cd1a567af4aaf58346b795d9f42431bf3ac68d09d1997c464c482a993cdd2437b2903b04cac95be529cdea1d16824591aa
+  data.tar.gz: 2cb78a3ed01d033011eeebb473ab52b155252ad4e2b6f1ddfe6bb1dcaf7cb6676b646c1fb2db0dc93184457a9365cb28ea216a2ee67bd664435d525acc3d306c

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--protected
+--markup markdown
+-
+README.md

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. This
+project adheres to [Semantic Versioning 2.0.0][semver]. Any violations of this
+scheme are considered to be bugs.
+
+[semver]: http://semver.org/spec/v2.0.0.html
+
+## 0.1.0 - 2015-07-20
+
+### Added
+
+- Initial version.

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 AcceptOn, Inc. (https://accepton.com)
+
+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,43 @@
+# AcceptOn
+
+[![Build Status](https://circleci.com/gh/accepton/accepton-ruby.svg?style=shield&circle-token=76d9d3cf6e881e7a80b22cc68c223725ade7fa31)](https://circleci.com/gh/accepton/accepton-ruby)
+
+## Documentation
+
+Please see the [Ruby developer documentation][rubydocs] for more information.
+
+[rubydocs]: http://developers.accepton.com/?ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'accepton'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install accepton
+
+Then, initialize the client like so:
+
+```ruby
+require "accepton"
+
+client = AcceptOn::Client.new(api_key: API_KEY, environment: :staging)
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write your code *and unit tests*
+4. Ensure all tests still pass (`bundle exec rspec`)
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new pull request

data/Rakefile

@@ -0,0 +1,26 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task test: :spec
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+require 'yardstick/rake/measurement'
+Yardstick::Rake::Measurement.new(:yardstick_measure) do |measurement|
+  measurement.output = 'measurement/report.txt'
+end
+
+require 'yardstick/rake/verify'
+Yardstick::Rake::Verify.new do |verify|
+  verify.threshold = 60.0
+  verify.require_exact_threshold = false
+end
+
+task default: [:spec, :rubocop, :verify_measurements]

data/accepton.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+require File.expand_path('../lib/accepton/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'accepton'
+  spec.version       = AcceptOn::VERSION
+  spec.authors       = ['AcceptOn']
+  spec.email         = ['developers@accepton.com']
+
+  spec.summary       = "AcceptOn allows you to get paid in your customer's preferred method"
+  spec.description   = "AcceptOn allows you to get paid in your customer's preferred method"
+  spec.homepage      = "https://developers.accepton.com"
+  spec.license       = 'MIT'
+
+  spec.files  = %w[.yardopts CHANGELOG.md LICENSE.md README.md Rakefile accepton.gemspec]
+  spec.files += Dir['lib/**/*.rb']
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'hashie', '~> 3.4'
+  spec.add_dependency 'http', '~> 0.6.4'
+
+  spec.add_development_dependency 'bundler', '~> 1.8'
+end

data/lib/accepton.rb

@@ -0,0 +1,12 @@
+require 'accepton/client'
+require 'accepton/error'
+require 'accepton/headers'
+require 'accepton/promo_code'
+require 'accepton/refund'
+require 'accepton/request'
+require 'accepton/version'
+
+require 'accepton/base'
+require 'accepton/charge'
+require 'accepton/refund'
+require 'accepton/transaction_token'

data/lib/accepton/api/promotion.rb

@@ -0,0 +1,75 @@
+require 'accepton/api/utils'
+
+module AcceptOn
+  module API
+    module Promotion
+      include AcceptOn::API::Utils
+
+      # Creates a promo code on AcceptOn
+      #
+      # @api public
+      #
+      # @example Create a "20OFF" promo code for $20 off of a purchase
+      #   create_promo_code(name: '20OFF',
+      #                     promo_type: 'amount',
+      #                     value: 20_00)
+      #
+      # @example Create a "10-percent" promo code for 10% off of a purchase
+      #   create_promo_code(name: '10per',
+      #                     promo_type: 'percentage',
+      #                     value: '10.0')
+      #
+      # @example Create a "5dollar" promo code that reduces a purchase to $5.00
+      #   create_promo_code(name: '5dollar',
+      #                     promo_type: 'fixed_price',
+      #                     value: 5_00)
+      #
+      # @param args [Hash]
+      # @option args [String] :name The promo code name, as given to customers.
+      # @option args [String] :promo_type The type of promo code.
+      # @option args [Numeric] :value The promo code amount.
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::PromoCode] The created promo code
+      def create_promo_code(args = {})
+        perform_post_with_object('/v1/promo_codes', args, AcceptOn::PromoCode)
+      end
+
+      # Deletes a promo code on AcceptOn
+      #
+      # @api public
+      #
+      # @example Deletes a promo code previously retrieved by the client
+      #   client.delete_promo_code(promo_code)
+      #
+      # @param promo_code [AcceptOn::PromoCode] The promo code to delete.
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::PromoCode] The deleted promo code
+      def delete_promo_code(promo_code)
+        perform_delete_with_object("/v1/promo_codes/#{promo_code.original_name}",
+                                   {},
+                                   AcceptOn::PromoCode)
+      end
+
+      # Updates a promo code on AcceptOn
+      #
+      # @api public
+      #
+      # @example Updates a "SUMMERFUN" promo code to $20 off of a purchase
+      #   promo_code.promo_type = 'amount'
+      #   promo_code.value = 20_00
+      #   client.update_promo_code(promo_code)
+      #
+      # @param promo_code [AcceptOn::PromoCode] The promo code to update.
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::PromoCode] The updated promo code
+      def update_promo_code(promo_code)
+        perform_put_with_object("/v1/promo_codes/#{promo_code.original_name}",
+                                promo_code.as_params,
+                                AcceptOn::PromoCode)
+      end
+    end
+  end
+end

data/lib/accepton/api/querying.rb

@@ -0,0 +1,66 @@
+require 'accepton/api/utils'
+
+module AcceptOn
+  module API
+    module Querying
+      include AcceptOn::API::Utils
+
+      # Retrieves a charge from the API
+      #
+      # @api public
+      #
+      # @param id [String] The charge identifier
+      #
+      # @raises [AcceptOn::Error]
+      # @return [AcceptOn::Charge]
+      def charge(id)
+        perform_get_with_object("/v1/charges/#{id}", {}, AcceptOn::Charge)
+      end
+
+      # Retrieves a page of charges from the API
+      #
+      # @api public
+      #
+      # @param args [Hash] A hash of query parameters
+      # @option args [DateTime, String] :end_date The latest data/time for
+      #         the objects to be created on.
+      # @option args [DateTime, String] :start_date The earliest date/time for
+      #         the objects to be created on.
+      # @option args [String] :order The order to sort by (asc or desc).
+      # @option args [String] :order_by The field to order by (e.g. created_at).
+      #
+      # @raises [AcceptOn::Error]
+      # @return [AcceptOn::Charge]
+      def charges(args = {})
+        perform_get_with_objects('/v1/charges', args, AcceptOn::Charge)
+      end
+
+      # Retrieves a promo code from AcceptOn
+      #
+      # @api public
+      #
+      # @example Retrieves the promo code with the name "20OFF"
+      #   client.promo_code('20OFF')
+      #
+      # @param name [String] The name of the promo code to retrieve.
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::PromoCode] The retrieved promo code
+      def promo_code(name)
+        perform_get_with_object("/v1/promo_codes/#{name}", {}, AcceptOn::PromoCode)
+      end
+
+      # Retrieves a transaction token from the API
+      #
+      # @api public
+      #
+      # @param id [String] The transaction token identifier
+      #
+      # @raises [AcceptOn::Error]
+      # @return [AcceptOn::TransactionToken]
+      def token(id)
+        perform_get_with_object("/v1/tokens/#{id}", {}, AcceptOn::TransactionToken)
+      end
+    end
+  end
+end

data/lib/accepton/api/refunding.rb

@@ -0,0 +1,26 @@
+require 'accepton/api/utils'
+
+module AcceptOn
+  module API
+    module Refunding
+      include AcceptOn::API::Utils
+
+      # Refunds a charge by the specified amount
+      #
+      # @api public
+      #
+      # @example Create a refund of $1.00 on charge chg_47ce6dacb1ec5124
+      #   refund(amount: 1_00, charge_id: 'chg_47ce6dacb1ec5124')
+      #
+      # @param args [Hash] Attributes to set on the refund
+      # @option args [Integer] :amount The amount in cents to refund
+      # @option args [String] :charge_id The id of the charge to refund
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::Refund]
+      def refund(args = {})
+        perform_post_with_object('/v1/refunds', args, AcceptOn::Refund)
+      end
+    end
+  end
+end

data/lib/accepton/api/tokenization.rb

@@ -0,0 +1,42 @@
+require 'accepton/api/utils'
+
+module AcceptOn
+  module API
+    module Tokenization
+      include AcceptOn::API::Utils
+
+      # Creates a transaction token on AcceptOn
+      #
+      # @api public
+      #
+      # @example Create a transaction token with an amount of $1.00
+      #   create_token(amount: 1_00)
+      #
+      # @example Create a transaction token with a description
+      #   create_token(amount: 1_00, description: 'Test')
+      #
+      # @example Create a transaction token with a description and application fee
+      #   create_token(amount: 10_99, description: 'Test', application_fee: 99)
+      #
+      # @example Create a Paypal-specific token that pays a merchant and charges
+      #          them an application fee
+      #   create_token(amount: 15_00, description: 'Test', application_fee: 1_50,
+      #                merchant_paypal_account: 'merchant@example.com')
+      #
+      # @param args [Hash] Attributes to set to the transaction token
+      # @option args [Integer] :amount The amount in cents of the transaction
+      # @option args [Integer] :application_fee The application fee to be passed on to the processor
+      # @option args [String]  :currency The currency to charge in (default: usd)
+      # @option args [String]  :description A description of the transaction
+      # @option args [String]  :merchant_paypal_account The merchant's Paypal
+      #                        account when you want to pay a merchant instead of
+      #                        yourself. Can be used with an application fee.
+      #
+      # @raise [AcceptOn::Error] If an API error happens
+      # @return [AcceptOn::TransactionToken]
+      def create_token(args = {})
+        perform_post_with_object('/v1/tokens', args, AcceptOn::TransactionToken)
+      end
+    end
+  end
+end

data/lib/accepton/api/utils.rb

@@ -0,0 +1,91 @@
+require 'accepton/request'
+
+module AcceptOn
+  module API
+    module Utils
+      private
+
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @return [klass]
+      def perform_delete_with_object(path, params, klass)
+        perform_request_with_object(:delete, path, params, klass)
+      end
+
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @return [klass]
+      def perform_get_with_object(path, params, klass)
+        perform_request_with_object(:get, path, params, klass)
+      end
+
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @return [Array<klass>]
+      def perform_get_with_objects(path, params, klass)
+        perform_request_with_objects(:get, path, params, klass)
+      end
+
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @return [klass]
+      def perform_post_with_object(path, params, klass)
+        perform_request_with_object(:post, path, params, klass)
+      end
+
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      def perform_put_with_object(path, params, klass)
+        perform_request_with_object(:put, path, params, klass)
+      end
+
+      # @param request_method [String, Symbol]
+      # @param path [String]
+      # @param params [Hash]
+      #
+      # @return [AcceptOn::Request]
+      def perform_request(request_method, path, params)
+        AcceptOn::Request.new(self, request_method, path, with_environment(params)).perform
+      end
+
+      # @param request_method [String, Symbol]
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @return [klass]
+      def perform_request_with_object(request_method, path, params, klass)
+        response = perform_request(request_method, path, params)
+        klass.new(response)
+      end
+
+      # @param request_method [String, Symbol]
+      # @param path [String]
+      # @param params [Hash]
+      # @param klass [Class]
+      #
+      # @returns [Array<klass>]
+      def perform_request_with_objects(request_method, path, params, klass)
+        perform_request(request_method, path, params)[:data].map do |element|
+          klass.new(element)
+        end
+      end
+
+      # @param params [Hash]
+      #
+      # @return [Hash]
+      def with_environment(params = {})
+        params.merge(environment: environment)
+      end
+    end
+  end
+end

data/lib/accepton/base.rb

@@ -0,0 +1,16 @@
+module AcceptOn
+  class Base
+    # Creates a object representation of a model
+    #
+    # @api public
+    #
+    # @param args [Hash]
+    # @return [AcceptOn::Base]
+    def initialize(args = {})
+      args.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      yield(self) if block_given?
+    end
+  end
+end

data/lib/accepton/charge.rb

@@ -0,0 +1,25 @@
+module AcceptOn
+  class Charge < Base
+    # @attr_reader amount [Integer] The amount charged in cents
+    # @attr_reader application_fee [Integer] The application fee by the
+    #              application owner in cents
+    # @attr_reader currency [String] The ISO code of the currency charged
+    # @attr_reader description [String] The description of the charge
+    # @attr_reader id [String] The charge identifier
+    # @attr_reader metadata [Hash] Any metadata about the charge
+    # @attr_reader refunded [Boolean] Whether the charge has been refunded
+    # @attr_reader remoted_id [String] The charge identifier on the processor
+    # @attr_reader status [String] The status of the charge
+    attr_reader :amount, :application_fee, :currency, :description,
+                :id, :metadata, :refunded, :remote_id, :status
+
+    # The time the charge was created
+    #
+    # @api public
+    #
+    # @return [Time]
+    def created_at
+      Time.parse(@created_at).utc unless @created_at.nil?
+    end
+  end
+end

data/lib/accepton/client.rb

@@ -0,0 +1,45 @@
+require 'accepton/api/promotion'
+require 'accepton/api/querying'
+require 'accepton/api/refunding'
+require 'accepton/api/tokenization'
+
+module AcceptOn
+  class Client
+    include AcceptOn::API::Promotion
+    include AcceptOn::API::Querying
+    include AcceptOn::API::Refunding
+    include AcceptOn::API::Tokenization
+
+    attr_accessor :api_key, :environment
+    attr_writer :user_agent
+
+    # Initializes a new Client object
+    #
+    # @param options [Hash]
+    # @return [AcceptOn::Client]
+    def initialize(options = {})
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      set_defaults
+      yield(self) if block_given?
+    end
+
+    # @return [Boolean]
+    def api_key?
+      !!api_key
+    end
+
+    # @return [String]
+    def user_agent
+      @user_agent ||= "accepton-ruby/#{AcceptOn::VERSION}"
+    end
+
+    private
+
+    # @return [void]
+    def set_defaults
+      self.environment = :production unless environment
+    end
+  end
+end

data/lib/accepton/error.rb

@@ -0,0 +1,70 @@
+module AcceptOn
+  class Error < StandardError
+    attr_reader :status_code
+
+    # Raised when AcceptOn returns a 4xx HTTP status code
+    ClientError = Class.new(self)
+
+    # Raised when AcceptOn returns a 400 HTTP status code
+    BadRequest = Class.new(ClientError)
+
+    # Raised when AcceptOn returns a 401 HTTP status code
+    Unauthorized = Class.new(ClientError)
+
+    # Raised when AcceptOn returns a 404 HTTP status code
+    NotFound = Class.new(ClientError)
+
+    # Raised when AcceptOn returns a 5xx HTTP status code
+    ServerError = Class.new(self)
+
+    # Raised when AcceptOn returns a 500 HTTP status code
+    InternalServerError = Class.new(ServerError)
+
+    # Raised when AcceptOn returns a 502 HTTP status code
+    BadGateway = Class.new(ServerError)
+
+    # Raised when AcceptOn returns a 503 HTTP status code
+    ServiceUnavailable = Class.new(ServerError)
+
+    # Raised when AcceptOn returns a 504 HTTP status code
+    GatewayTimeout = Class.new(ServerError)
+
+    ERRORS = {
+      400 => AcceptOn::Error::BadRequest,
+      401 => AcceptOn::Error::Unauthorized,
+      404 => AcceptOn::Error::NotFound,
+      500 => AcceptOn::Error::InternalServerError,
+      502 => AcceptOn::Error::BadGateway,
+      503 => AcceptOn::Error::ServiceUnavailable,
+      504 => AcceptOn::Error::GatewayTimeout
+    }
+
+    class << self
+      # @param response_body [Hashie::Mash]
+      # @param status_code [Integer]
+      # @return [AcceptOn::Error]
+      def from_response(response_body, status_code)
+        return unless ERRORS.key?(status_code)
+        error_class = ERRORS[status_code]
+        message = parse_error(response_body)
+        error_class.new(message, status_code)
+      end
+
+      private
+
+      def parse_error(body)
+        return '' if body.nil? || body.empty?
+
+        body.error.message
+      end
+    end
+
+    # @param message [String]
+    # @param code [Integer]
+    # @return [AcceptOn::Error]
+    def initialize(message = '', code = nil)
+      super(message)
+      @status_code = code
+    end
+  end
+end

data/lib/accepton/headers.rb

@@ -0,0 +1,24 @@
+module AcceptOn
+  class Headers
+    # @param client [AcceptOn::Client]
+    # @return [AcceptOn::Headers]
+    def initialize(client)
+      @client = client
+    end
+
+    # @return [Hash]
+    def request_headers
+      headers = {}
+      headers[:accept] = 'application/json'
+      headers[:authorization] = bearer_auth_header
+      headers[:user_agent] = @client.user_agent
+      headers
+    end
+
+    private
+
+    def bearer_auth_header
+      "Bearer #{@client.api_key}"
+    end
+  end
+end

data/lib/accepton/promo_code.rb

@@ -0,0 +1,49 @@
+require 'accepton/base'
+
+module AcceptOn
+  class PromoCode < Base
+    # @attr_reader created_at [DateTime] The time the promo code was created.
+    # @attr_reader original_name [String] The original promo code name, if the
+    #                                     name was modified.
+    # @api public
+    attr_reader :created_at, :original_name
+
+    # @attr_accessor name [String] The promo code as given to a customer
+    # @attr_accessor promo_type [String] The type of promo code. One of:
+    #                                    "amount", "fixed_price", or
+    #                                    "percentage".
+    # @attr_accessor value [Numeric] The amount of discount to apply, based on
+    #                                the type. If promo_type is "amount" or
+    #                                "fixed_price", an integer amount in
+    #                                cents. If type is "percentage", a decimal
+    #                                percentage.
+    # @api public
+    attr_accessor :name, :promo_type, :value
+
+    # Creates a hash representation of the promo code's current values
+    #
+    # @return [Hash] A hash representing the promo code.
+    def as_params
+      {name: name, promo_type: promo_type, value: value}
+    end
+
+    # Sets the new name of the promo code and memorizes the original
+    #
+    # @api public
+    #
+    # @param name [String] The new name to set for the promo code.
+    def name=(name)
+      @original_name ||= @name
+      @name = name
+    end
+
+    # Gets the original name of the promo code
+    #
+    # @api public
+    #
+    # @return [String] The original name for the promo code.
+    def original_name
+      @original_name || @name
+    end
+  end
+end

data/lib/accepton/refund.rb

@@ -0,0 +1,13 @@
+module AcceptOn
+  class Refund < Base
+    # @attr_reader amount [Integer] The amount of the refund in cents
+    # @attr_reader created [DateTime] The time the refund was created
+    # @attr_reader currency [String] The ISO currency code of the refund
+    # @attr_reader id [String] The refund identifier
+    # @attr_reader metadata [Hash] Any metadata associated with the refund
+    # @attr_reader reason [String] The reason for the refund
+    #
+    # @api public
+    attr_reader :amount, :created, :currency, :id, :metadata, :reason
+  end
+end

data/lib/accepton/request.rb

@@ -0,0 +1,54 @@
+require 'addressable/uri'
+require 'hashie/mash'
+require 'http'
+require 'accepton/headers'
+
+module AcceptOn
+  class Request
+    URLS = {
+      development: 'http://checkout.accepton.dev',
+      staging: 'https://staging-checkout.accepton.com',
+      production: 'https://checkout.accepton.com'
+    }.freeze
+
+    attr_accessor :client, :headers, :options, :path
+
+    # @param client [AcceptOn::Client]
+    # @param request_method [String, Symbol]
+    # @param path [String]
+    # @param options [Hash]
+    # @return [Accepton::Request]
+    def initialize(client, request_method, path, options = {})
+      options = default_options.merge(options)
+      url = URLS[options.delete(:environment).to_sym]
+      @client = client
+      @request_method = request_method
+      @uri = Addressable::URI.parse(path.start_with?('http') ? path : url + path)
+      @options = options
+      @path = @uri.path
+      @headers = AcceptOn::Headers.new(@client).request_headers
+    end
+
+    # @return [Hashie::Mash] if the request reutrns a success code
+    # @raise [AcceptOn::Error] if the request returns a failure code
+    def perform
+      options_key = @request_method == :get ? :params : :form
+      response = HTTP.with(@headers).public_send(@request_method, @uri.to_s, options_key => @options)
+      response_body = Hashie::Mash.new(response.parse)
+      fail_or_return_response_body(response_body, response.code)
+    end
+
+    private
+
+    def fail_or_return_response_body(body, status_code)
+      error = AcceptOn::Error.from_response(body, status_code)
+      fail(error) if error
+      body
+    end
+
+    # @return [Hash]
+    def default_options
+      {environment: :production}
+    end
+  end
+end

data/lib/accepton/transaction_token.rb

@@ -0,0 +1,15 @@
+module AcceptOn
+  class TransactionToken < Base
+    # @attr_reader amount [Integer] The amount of the transaction in cents
+    # @attr_reader application_fee [Integer] The amount of application fee
+    # @attr_reader created [DateTime] The time the transaction was created
+    # @attr_reader description [String] A description of the transaction
+    # @attr_reader id [String] The transaction identifier
+    # @attr_reader merchant_paypal_account [String] The merchant's Paypal
+    #              account when you want to pay a merchant instead of
+    #              yourself. Can be used with an application fee.
+    # @api public
+    attr_reader :amount, :application_fee, :created, :description, :id,
+                :merchant_paypal_account
+  end
+end

data/lib/accepton/version.rb

@@ -0,0 +1,3 @@
+module AcceptOn
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: accepton
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- AcceptOn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: AcceptOn allows you to get paid in your customer's preferred method
+email:
+- developers@accepton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- Rakefile
+- accepton.gemspec
+- lib/accepton.rb
+- lib/accepton/api/promotion.rb
+- lib/accepton/api/querying.rb
+- lib/accepton/api/refunding.rb
+- lib/accepton/api/tokenization.rb
+- lib/accepton/api/utils.rb
+- lib/accepton/base.rb
+- lib/accepton/charge.rb
+- lib/accepton/client.rb
+- lib/accepton/error.rb
+- lib/accepton/headers.rb
+- lib/accepton/promo_code.rb
+- lib/accepton/refund.rb
+- lib/accepton/request.rb
+- lib/accepton/transaction_token.rb
+- lib/accepton/version.rb
+homepage: https://developers.accepton.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.5
+signing_key: 
+specification_version: 4
+summary: AcceptOn allows you to get paid in your customer's preferred method
+test_files: []
+has_rdoc: