payjp 0.0.2

data/lib/payjp/account.rb

@@ -0,0 +1,11 @@
+module Payjp
+  class Account < APIResource
+    def url
+      '/v1/accounts'
+    end
+
+    def self.retrieve
+      super(Object.new)
+    end
+  end
+end

data/lib/payjp/api_operations/create.rb

@@ -0,0 +1,16 @@
+module Payjp
+  module APIOperations
+    module Create
+      module ClassMethods
+        def create(params = {}, opts = {})
+          response, opts = request(:post, url, params, opts)
+          Util.convert_to_payjp_object(response, opts)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/payjp/api_operations/delete.rb

@@ -0,0 +1,11 @@
+module Payjp
+  module APIOperations
+    module Delete
+      def delete(params = {}, opts = {})
+        opts = Util.normalize_opts(opts)
+        response, opts = request(:delete, url, params, opts)
+        refresh_from(response, opts)
+      end
+    end
+  end
+end

data/lib/payjp/api_operations/list.rb

@@ -0,0 +1,17 @@
+module Payjp
+  module APIOperations
+    module List
+      module ClassMethods
+        def all(filters = {}, opts = {})
+          opts = Util.normalize_opts(opts)
+          response, opts = request(:get, url, filters, opts)
+          Util.convert_to_payjp_object(response, opts)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/payjp/api_operations/request.rb

@@ -0,0 +1,39 @@
+module Payjp
+  module APIOperations
+    module Request
+      module ClassMethods
+        OPTS_KEYS_TO_PERSIST = Set[:api_key, :api_base, :payjp_account, :payjp_version]
+
+        def request(method, url, params = {}, opts = {})
+          opts = Util.normalize_opts(opts)
+
+          headers = opts.clone
+          api_key = headers.delete(:api_key)
+          api_base = headers.delete(:api_base)
+          # Assume all remaining opts must be headers
+
+          response, opts[:api_key] = Payjp.request(method, url, api_key, params, headers, api_base)
+
+          # Hash#select returns an array before 1.9
+          opts_to_persist = {}
+          opts.each do |k, v|
+            opts_to_persist[k] = v if OPTS_KEYS_TO_PERSIST.include?(k)
+          end
+
+          [response, opts_to_persist]
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected
+
+      def request(method, url, params = {}, opts = {})
+        opts = @opts.merge(Util.normalize_opts(opts))
+        self.class.request(method, url, params, opts)
+      end
+    end
+  end
+end

data/lib/payjp/api_operations/update.rb

@@ -0,0 +1,17 @@
+module Payjp
+  module APIOperations
+    module Update
+      def save(params = {})
+        values = self.class.serialize_params(self).merge(params)
+
+        if values.length > 0
+          values.delete(:id)
+
+          response, opts = request(:post, url, values)
+          refresh_from(response, opts)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/payjp/api_resource.rb

@@ -0,0 +1,35 @@
+module Payjp
+  class APIResource < PayjpObject
+    include Payjp::APIOperations::Request
+
+    def self.class_name
+      name.split('::')[-1]
+    end
+
+    def self.url
+      if self == APIResource
+        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Charge, Customer, etc.)')
+      end
+      "/v1/#{CGI.escape(class_name.downcase)}s"
+    end
+
+    def url
+      unless id = self['id']
+        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+      end
+      "#{self.class.url}/#{CGI.escape(id)}"
+    end
+
+    def refresh
+      response, opts = request(:get, url, @retrieve_params)
+      refresh_from(response, opts)
+    end
+
+    def self.retrieve(id, opts = {})
+      opts = Util.normalize_opts(opts)
+      instance = new(id, opts)
+      instance.refresh
+      instance
+    end
+  end
+end

data/lib/payjp/card.rb

@@ -0,0 +1,18 @@
+module Payjp
+  class Card < APIResource
+    include Payjp::APIOperations::Create
+    include Payjp::APIOperations::Update
+    include Payjp::APIOperations::Delete
+    include Payjp::APIOperations::List
+
+    def url
+      if respond_to?(:customer)
+        "#{Customer.url}/#{CGI.escape(customer)}/cards/#{CGI.escape(id)}"
+      end
+    end
+
+    def self.retrieve(_id, _opts = nil)
+      raise NotImplementedError.new("Cards cannot be retrieved without a customer ID. Retrieve a card using customer.cards.retrieve('card_id')")
+    end
+  end
+end

data/lib/payjp/charge.rb

@@ -0,0 +1,27 @@
+module Payjp
+  class Charge < APIResource
+    include Payjp::APIOperations::List
+    include Payjp::APIOperations::Create
+    include Payjp::APIOperations::Update
+
+    def refund(params = {}, opts = {})
+      response, opts = request(:post, refund_url, params, opts)
+      refresh_from(response, opts)
+    end
+
+    def capture(params = {}, opts = {})
+      response, opts = request(:post, capture_url, params, opts)
+      refresh_from(response, opts)
+    end
+
+    private
+
+    def refund_url
+      url + '/refund'
+    end
+
+    def capture_url
+      url + '/capture'
+    end
+  end
+end

data/lib/payjp/customer.rb

@@ -0,0 +1,8 @@
+module Payjp
+  class Customer < APIResource
+    include Payjp::APIOperations::Create
+    include Payjp::APIOperations::Delete
+    include Payjp::APIOperations::Update
+    include Payjp::APIOperations::List
+  end
+end

data/lib/payjp/errors/api_connection_error.rb

@@ -0,0 +1,4 @@
+module Payjp
+  class APIConnectionError < PayjpError
+  end
+end

data/lib/payjp/errors/api_error.rb

@@ -0,0 +1,4 @@
+module Payjp
+  class APIError < PayjpError
+  end
+end

data/lib/payjp/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module Payjp
+  class AuthenticationError < PayjpError
+  end
+end

data/lib/payjp/errors/card_error.rb

@@ -0,0 +1,11 @@
+module Payjp
+  class CardError < PayjpError
+    attr_reader :param, :code
+
+    def initialize(message, param, code, http_status = nil, http_body = nil, json_body = nil)
+      super(message, http_status, http_body, json_body)
+      @param = param
+      @code = code
+    end
+  end
+end

data/lib/payjp/errors/invalid_request_error.rb

@@ -0,0 +1,10 @@
+module Payjp
+  class InvalidRequestError < PayjpError
+    attr_accessor :param
+
+    def initialize(message, param, http_status = nil, http_body = nil, json_body = nil)
+      super(message, http_status, http_body, json_body)
+      @param = param
+    end
+  end
+end

data/lib/payjp/errors/payjp_error.rb

@@ -0,0 +1,20 @@
+module Payjp
+  class PayjpError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message = nil, http_status = nil, http_body = nil, json_body = nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/payjp/event.rb

@@ -0,0 +1,5 @@
+module Payjp
+  class Event < APIResource
+    include Payjp::APIOperations::List
+  end
+end

data/lib/payjp/list_object.rb

@@ -0,0 +1,33 @@
+module Payjp
+  class ListObject < PayjpObject
+    include Payjp::APIOperations::Request
+
+    def [](k)
+      case k
+      when String, Symbol
+        super
+      else
+        raise ArgumentError.new("You tried to access the #{k.inspect} index, but ListObject types only support String keys. (HINT: List calls return an object with a 'data' (which is the data array). You likely want to call #data[#{k.inspect}])")
+      end
+    end
+
+    def each(&blk)
+      data.each(&blk)
+    end
+
+    def retrieve(id, opts = {})
+      response, opts = request(:get, "#{url}/#{CGI.escape(id)}", {}, opts)
+      Util.convert_to_payjp_object(response, opts)
+    end
+
+    def create(params = {}, opts = {})
+      response, opts = request(:post, url, params, opts)
+      Util.convert_to_payjp_object(response, opts)
+    end
+
+    def all(params = {}, opts = {})
+      response, opts = request(:get, url, params, opts)
+      Util.convert_to_payjp_object(response, opts)
+    end
+  end
+end

data/lib/payjp/payjp_object.rb

@@ -0,0 +1,259 @@
+module Payjp
+  class PayjpObject
+    include Enumerable
+
+    @@permanent_attributes = Set.new([:id])
+
+    # The default :id method is deprecated and isn't useful to us
+    undef :id if method_defined?(:id)
+
+    def initialize(id = nil, opts = {})
+      # parameter overloading!
+      if id.is_a?(Hash)
+        @retrieve_params = id.dup
+        @retrieve_params.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_params = {}
+      end
+
+      @opts = opts
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      @values[:id] = id if id
+    end
+
+    def self.construct_from(values, opts = {})
+      new(values[:id]).refresh_from(values, opts)
+    end
+
+    def to_s(*_args)
+      JSON.pretty_generate(@values)
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !id.nil?) ? " id=#{id}" : ""
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
+
+    def refresh_from(values, opts, partial = false)
+      @opts = opts
+      @original_values = Marshal.load(Marshal.dump(values)) # deep copy
+      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = Util.convert_to_payjp_object(v, @opts)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+
+      self
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*_a)
+      JSON.generate(@values)
+    end
+
+    def as_json(*a)
+      @values.as_json(*a)
+    end
+
+    def to_hash
+      @values.inject({}) do |acc, (key, value)|
+        acc[key] = value.respond_to?(:to_hash) ? value.to_hash : value
+        acc
+      end
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    def _dump(_level)
+      Marshal.dump([@values, @opts])
+    end
+
+    def self._load(args)
+      values, opts = Marshal.load(args)
+      construct_from(values, opts)
+    end
+
+    if RUBY_VERSION < '1.9.2'
+      def respond_to?(symbol)
+        @values.has_key?(symbol) || super
+      end
+    end
+
+    def serialize_nested_object(key)
+      new_value = @values[key]
+      return {} if new_value.is_a?(APIResource)
+
+      if @unsaved_values.include?(key)
+        # the object has been reassigned
+        # e.g. as object.key = {foo => bar}
+        update = new_value
+        new_keys = update.keys.map(&:to_sym)
+
+        # remove keys at the server, but not known locally
+        if @original_values.include?(key)
+          keys_to_unset = @original_values[key].keys - new_keys
+          keys_to_unset.each { |key| update[key] = '' }
+        end
+
+        update
+      else
+        # can be serialized normally
+        self.class.serialize_params(new_value)
+      end
+    end
+
+    def self.serialize_params(obj, original_value = nil)
+      case obj
+      when nil
+        ''
+      when PayjpObject
+        unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+        obj_values = obj.instance_variable_get(:@values)
+        update_hash = {}
+
+        unsaved_keys.each do |k|
+          update_hash[k] = serialize_params(obj_values[k])
+        end
+
+        obj_values.each do |k, v|
+          if v.is_a?(PayjpObject) || v.is_a?(Hash)
+            update_hash[k] = obj.serialize_nested_object(k)
+          elsif v.is_a?(Array)
+            original_value = obj.instance_variable_get(:@original_values)[k]
+            if original_value && original_value.length > v.length
+              # url params provide no mechanism for deleting an item in an array,
+              # just overwriting the whole array or adding new items. So let's not
+              # allow deleting without a full overwrite until we have a solution.
+              raise ArgumentError.new(
+                "You cannot delete an item from an array, you must instead set a new array"
+              )
+            end
+            update_hash[k] = serialize_params(v, original_value)
+          end
+        end
+
+        update_hash
+      when Array
+        update_hash = {}
+        obj.each_with_index do |value, index|
+          update = serialize_params(value)
+          if update != {} && (!original_value || update != original_value[index])
+            update_hash[index] = update
+          end
+        end
+
+        if update_hash == {}
+          nil
+        else
+          update_hash
+        end
+      else
+        obj
+      end
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            if v == ""
+              raise ArgumentError.new(
+                "You cannot set #{k} to an empty string." \
+                "We interpret empty strings as nil in requests." \
+                "You may set #{self}.#{k} = nil to delete the property.")
+            end
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      # TODO: only allow setting in updateable classes.
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        add_accessors([attr])
+        begin
+          mth = method(name)
+        rescue NameError
+          raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
+        end
+        return mth.call(args[0])
+      else
+        return @values[name] if @values.has_key?(name)
+      end
+
+      begin
+        super
+      rescue NoMethodError => e
+        if @transient_values.include?(name)
+          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Payjp's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
+        else
+          raise
+        end
+      end
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      @values && @values.has_key?(symbol) || super
+    end
+  end
+end