webpay 2.0.0

data/lib/webpay.rb

@@ -0,0 +1,66 @@
+require 'webpay/version'
+
+# Toplevel module of WebPay gem.
+# This is the start point.
+module WebPay
+  autoload(:Client, 'webpay/client')
+  autoload(:Operations, 'webpay/operations')
+  autoload(:WebPayError, 'webpay/webpay_error')
+  autoload(:APIConnectionError, 'webpay/webpay_error')
+  autoload(:APIError, 'webpay/webpay_error')
+  autoload(:AuthenticationError, 'webpay/webpay_error')
+  autoload(:CardError, 'webpay/webpay_error')
+  autoload(:InvalidRequestError, 'webpay/webpay_error')
+  autoload(:Entity, 'webpay/entity')
+  autoload(:EntityList, 'webpay/entity_list')
+  autoload(:Account, 'webpay/account')
+  autoload(:Card, 'webpay/card')
+  autoload(:Charge, 'webpay/charge')
+  autoload(:Customer, 'webpay/customer')
+  autoload(:Event, 'webpay/event')
+  autoload(:Token, 'webpay/token')
+  autoload(:ResponseConverter, 'webpay/response_converter')
+
+  @api_base = 'https://api.webpay.jp'
+  @api_version = '/v1'
+  @api_key = nil
+
+  class << self
+    # Absolute path to SSL CA file.
+    # This gem includes SSL CA file as lib/data/ca-certificates.crt.
+    def ssl_ca_file
+      File.join(File.dirname(File.expand_path(__FILE__)), 'data', 'ca-certificates.crt')
+    end
+
+    # Current client object.
+    # client is memoized, and nullified when @api_base or @api_key is modified.
+    def client
+      @client ||= Client.new(@api_key, @api_base, @api_version)
+    end
+
+    # Set api_base, the base URL of API.
+    # Configure this before sending any request.
+    # Take care when using unofficial WebPay API.
+    def api_base=(new_value)
+      @api_base = new_value
+      @client = nil
+    end
+
+    # Set api_key, your token for accessing API.
+    # Configure this before sending any request.
+    def api_key=(new_value)
+      @api_key = new_value
+      @client = nil
+    end
+
+    # Get current api_base
+    def api_base
+      @api_base
+    end
+
+    # Get current api_key
+    def api_key
+      @api_key
+    end
+  end
+end

data/lib/webpay/account.rb

@@ -0,0 +1,20 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = account</code>
+  class Account < Entity
+    class << self
+
+      # Get the account of api_key's owner
+      # @return [Account] the account of api_key's owner
+      def retrieve
+        convert(WebPay.client.get(path))
+      end
+
+      # @api private
+      # @return [String] Relative path to API root: <code>'/account'</code>
+      def path
+        '/account'
+      end
+    end
+  end
+end

data/lib/webpay/card.rb

@@ -0,0 +1,13 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = card</code>.
+  # Card is not accessible as an API endpoint
+  class Card < Entity
+
+    # Check equality with rhs
+    # @return [Boolean] true if rhs is the same object, or it is a Card with the same fingerprint value
+    def ==(other)
+      other.equals?(self) || (other.instance_of?(self.class) && other.fingerprint == self.fingerprint)
+    end
+  end
+end

data/lib/webpay/charge.rb

@@ -0,0 +1,33 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = charge</code>
+  class Charge < Entity
+    install_class_operations :create, :retrieve, :all
+
+    # @return [String] Relative path to API root
+    # @api private
+    def self.path
+      '/charges'
+    end
+
+    # Refund this charge
+    # @param [Hash] params request parameters
+    # @option params [Integer] :amount The amount to refund. Default is all amount.
+    def refund(params = {})
+      update_attributes(WebPay.client.post([path, 'refund'].join('/'), params))
+    end
+
+    # Capture a not captured charge
+    # @param [Hash] params request parameters
+    # @option params [Integer] :amount The amount to capture. Default is all amount.
+    def capture(params = {})
+      update_attributes(WebPay.client.post([path, 'capture'].join('/'), params))
+    end
+
+    # @return [String] Relative path of instance to API root
+    # @api private
+    def path
+      "/charges/#{id}"
+    end
+  end
+end

data/lib/webpay/client.rb

@@ -0,0 +1,62 @@
+require 'faraday'
+require 'json'
+
+module WebPay
+
+  # API client wrapping of Faraday.
+  # Not intended to use directly.
+  class Client
+
+    # Initialize client
+    #
+    # @param api_key [String] User's secret API key
+    # @param api_base [String] the URL without trailing '/'.
+    # @param api_version [String] the path indicating API version. `/v1`.
+    #
+    # @example Client for the default endpoint
+    #     Client.new('test_secret_XXXX', 'https://api.webpay.jp', '/v1')
+    def initialize(api_key, api_base, api_version)
+      ssl_options = {ca_file: WebPay.ssl_ca_file}
+      default_headers = {
+        'Authorization' => "Bearer #{api_key}",
+        'User-Agent' => "WebPay#{api_version} RubyBinding/#{WebPay::VERSION}"
+      }
+      @conn = Faraday.new(api_base, ssl: ssl_options, headers: default_headers) do |builder|
+        builder.request :url_encoded
+        builder.adapter Faraday.default_adapter
+      end
+      @api_version = api_version
+    end
+
+    # Convert faraday response to a hash by decoding JSON.
+    # This raises error if the response indicates error status.
+    #
+    # @api private
+    # @param response [Faraday::Response]
+    # @return [Hash] Raw object
+    # @raise [WebPay::WebPayError] For invalid requests (4xx) or internal server error (5xx)
+    def handle_response(response)
+      case response.status
+      when 200..299
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError => e
+          raise WebPay::APIConnectionError.new("Response JSON is broken. #{e.message}: #{response.body}", e)
+        end
+      else
+        raise WebPay::WebPayError.from_response(response.status, response.body)
+      end
+    end
+
+    Faraday::Connection::METHODS.each do |method|
+      define_method(method) do |url, *args|
+        begin
+          response = @conn.__send__(method, @api_version + url, *args)
+        rescue Faraday::Error::ClientError => e
+          raise WebPay::APIConnectionError.faraday_error(e)
+        end
+        handle_response(response)
+      end
+    end
+  end
+end

data/lib/webpay/customer.rb

@@ -0,0 +1,70 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = customer</code>
+  class Customer < Entity
+    install_class_operations :create, :retrieve, :all
+
+    # Attributes updated by assignment.
+    # These attributes are sent on save.
+    # Only description, card, and email are effective.
+    attr_accessor :updated_attributes
+
+    # @return [String] Relative path to API root
+    # @api private
+    def self.path
+      '/customers'
+    end
+
+    # @api private
+    def initialize(attributes)
+      @updated_attributes = {}
+      super(attributes)
+    end
+
+    # <code>object['key']=</code> is wrapper for <code>object.key =</code>.
+    # Method call style is recommended.
+    # @return [Object] Given value
+    def []=(key, value)
+      send("#{key}=", value)
+    end
+
+    # <code>object['key']</code> is wrapper for <code>object.key</code>.
+    # Method call style is recommended.
+    # @return [Object] The attribute's value
+    def [](key)
+      send(key)
+    end
+
+    [:description, :card, :email].each do |attr|
+      define_method("#{attr}=") do |value|
+        @updated_attributes[attr.to_s] = value
+      end
+      define_method("#{attr}") do
+        @updated_attributes[attr.to_s] || @attributes[attr.to_s]
+      end
+    end
+
+    # Send update request of modified attributes.
+    # description, card, and email are modifiable.
+    # @return [Customer] this object with attributes updated
+    def save
+      update_attributes(WebPay.client.post(path, @updated_attributes))
+      @updated_attributes = {}
+      self
+    end
+
+    # Delete this customer.
+    # This operation cannot be undone.
+    # @return [Boolean] true if operation succeeded
+    def delete
+      response = WebPay.client.delete(path)
+      response['deleted']
+    end
+
+    # @return [String] Relative path of instance to API root
+    # @api private
+    def path
+      "/customers/#{id}"
+    end
+  end
+end

data/lib/webpay/entity.rb

@@ -0,0 +1,63 @@
+module WebPay
+
+  # The base class for entity objects
+  # @abstract
+  class Entity
+    class << self
+      include Operations
+
+      # Convert hash API response into an entity object
+      # @param [Hash] hash Raw API response
+      # @return [Entity] An entity object corresponds to hash
+      def convert(hash)
+        converter = ResponseConverter.new
+        converter.convert(hash)
+      end
+    end
+
+    # Attributes of this object.
+    # <code>method_missing</code> and <code>#[]</code> are provided to access attributes
+    attr_reader :attributes
+
+    # Initialized by ResponseConverter
+    # @api private
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    # @return [Boolean] true if rhs is the same object or has the same id
+    def ==(other)
+      other.equal?(self) || (other.instance_of?(self.class) && other.id == self.id)
+    end
+
+    # Access attribute.
+    # Using the attribute name as a method is recommended.
+    # @return [Object] The attribute's value
+    def [](key)
+      send(key)
+    end
+
+    # Provide access to attributes
+    # @return [Object] The attribute's value
+    def method_missing(method_name, *args, &block)
+      key = method_name.to_s
+      if @attributes.has_key?(key)
+        @attributes[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.has_key?(method_name.to_s) || super
+    end
+
+    private
+    def update_attributes(attributes)
+      raise "unexpected object" if attributes['object'] != @attributes['object']
+      new_object = ResponseConverter.new.convert(attributes)
+      @attributes = new_object.attributes
+      self
+    end
+  end
+end

data/lib/webpay/entity_list.rb

@@ -0,0 +1,25 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = list</code>.
+  # This enumerates containing data.
+  class EntityList < Entity
+    include Enumerable
+
+    # @return [Boolean] true if rhs is the same object or id lists of containing data are the same
+    def ==(other)
+      other.equal?(self) ||
+        (other.instance_of?(self.class) && other.data.map(&:id) == self.data.map(&:id))
+    end
+
+    # Return the all entry count, not limited by <code>limit</code>.
+    # This overrides <code>Enumerable#count</code>.  Not necessarily equal to the data size.
+    def count
+      @attributes['count']
+    end
+
+    # Enumerate containing data.
+    def each(&block)
+      self.data.each(&block)
+    end
+  end
+end

data/lib/webpay/event.rb

@@ -0,0 +1,19 @@
+module WebPay
+
+  # Object for API response hash object with <code>hash['object'] = event</code>
+  class Event < Entity
+    install_class_operations :retrieve, :all
+
+    # @return [String] Relative path to API root
+    # @api private
+    def self.path
+      '/events'
+    end
+
+    # Entity object for <code>event.data</code>
+    # This entity has <code>object</code> on which event occurred,
+    # and <code>previous_attributes</code> if some of attributes are modified on the event.
+    class Data < Entity
+    end
+  end
+end

data/lib/webpay/operations.rb

@@ -0,0 +1,49 @@
+module WebPay
+
+  # This module installs collection operations to entities.
+  # Some of <code>create</code>, <code>retrieve</code>, and <code>all</code> are defined as class methods.
+  module Operations
+
+    # Install selected operations
+    # @api private
+    def install_class_operations(*operations)
+      define_create if operations.include?(:create)
+      define_retrieve if operations.include?(:retrieve)
+      define_all if operations.include?(:all)
+    end
+
+    # Define <code>create</code> method
+    # @api private
+    def define_create
+      instance_eval do
+        def create(params = {})
+          convert(WebPay.client.post(path, params))
+        end
+      end
+    end
+
+    # Define <code>retrieve(id)</code> method
+    # @api private
+    def define_retrieve
+      instance_eval do
+        def retrieve(id)
+          id = id.to_s
+          if id.strip == ''
+            raise InvalidRequestError.invalid_id(id)
+          end
+          convert(WebPay.client.get([path, id].join('/')))
+        end
+      end
+    end
+
+    # Define <code>all</code> method
+    # @api private
+    def define_all
+      instance_eval do
+        def all(params = {})
+          convert(WebPay.client.get(path, params))
+        end
+      end
+    end
+  end
+end

data/lib/webpay/response_converter.rb

@@ -0,0 +1,45 @@
+module WebPay
+
+  # Converts raw Hash response to an entity
+  class ResponseConverter
+
+    # Converts raw Hash response to an entity.
+    # This recursively changes internal objects.
+    # @param [Hash] attributes Raw API response
+    # @return [Entity] Corresponding entity
+    def convert(attributes)
+      case attributes['object']
+      when 'card'
+        Card.new(attributes)
+      when 'charge'
+        if attributes['card']
+          attributes['card'] = convert(attributes['card'])
+        end
+        Charge.new(attributes)
+      when 'customer'
+        if attributes['active_card']
+          attributes['active_card'] = convert(attributes['active_card'])
+        end
+        Customer.new(attributes)
+      when 'token'
+        if attributes['card']
+          attributes['card'] = convert(attributes['card'])
+        end
+        Token.new(attributes)
+      when 'event'
+        if attributes['data']
+          attributes['data']['object'] = convert(attributes['data']['object'])
+          attributes['data'] = Event::Data.new(attributes['data'])
+        end
+        Event.new(attributes)
+      when 'account'
+        Account.new(attributes)
+
+      when 'list'
+        attributes['data'] ||= []
+        attributes['data'].map! { |line| convert(line) }
+        EntityList.new(attributes)
+      end
+    end
+  end
+end