balanced 0.8.2 → 1.0.beta1

data/lib/balanced/resources/debit.rb

@@ -13,30 +13,22 @@ module Balanced
   #
   class Debit
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
-    def initialize attributes = {}
-      Balanced::Utils.stringify_keys! attributes
-      unless attributes.has_key? 'uri'
-        attributes['uri'] = self.class.uri
-      end
-      super attributes
-    end
+    define_hypermedia_types [:debits]
 
     # Refunds this Debit. If no amount is specified it will refund the entire
     # amount of the Debit, you may create many Refunds up to the sum total
     # of the original Debit's amount.
     #
     # @return [Refund]
-    def refund *args
-      warn_on_positional args
+    def refund(options={})
 
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      amount = args[0] || options.fetch(:amount) { nil }
-      description = args[1] || options.fetch(:description) { nil }
+      amount = options[:amount]
+      description = options[:description]
 
       refund = Refund.new(
-          :uri => self.refunds_uri,
-          :debit_uri => self.uri,
+          :href => self.refunds.href,
           :amount => amount,
           :description => description
       )

data/lib/balanced/resources/event.rb

@@ -7,21 +7,27 @@ module Balanced
   #
   class Event
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
+    define_hypermedia_types [:events]
   end
 
   # Represents a single event being sent to a callback.
   #
   class EventCallback
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
+    define_hypermedia_types [:event_callbacks]
   end
 
   # Represents a single log of an event sent to a callback.
   #
   class Log
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
+    define_hypermedia_types [:logs]
   end
 
 end

data/lib/balanced/resources/funding_instrument.rb

@@ -0,0 +1,11 @@
+module Balanced
+
+  class FundingInstrument
+
+  end
+
+  class DebitableFundingInstrument < FundingInstrument
+
+  end
+
+end

data/lib/balanced/resources/hypermedia.rb

@@ -0,0 +1,28 @@
+module Balanced
+
+  module HypermediaRegistry
+
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def define_hypermedia_types(types)
+        @hypermedia_types = types.map! do |t|
+          t.to_s
+        end.sort!.freeze
+
+        @hypermedia_types.each do |type|
+          Balanced.hypermedia_registry[type] = self
+        end
+      end
+
+      # @return [Array, nil] The list of hypermedia types this class is
+      # mapped to for interacting with the resource.
+      attr_reader :hypermedia_types
+    end
+
+  end
+
+end

data/lib/balanced/resources/marketplace.rb

@@ -3,8 +3,9 @@ module Balanced
   #
   class Marketplace
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
-    @@marketplace_uri = nil
+    define_hypermedia_types [:marketplaces]
 
     class << self
 
@@ -13,37 +14,13 @@ module Balanced
       #
       # @return [Marketplace]
       def my_marketplace
-        marketplace = Balanced::Merchant.me.marketplace
-        @@marketplace_uri = marketplace.uri if marketplace
-        marketplace
-      end
-      alias mine my_marketplace
-
-      # @return [String, nil] the marketplace's URI
-      def marketplace_uri
-        if !@@marketplace_uri and Balanced.is_configured_with_api_key?
-          begin
-            mine
-          rescue Balanced::Error
-            # do nothing..
-          end
-        end
-        @@marketplace_uri
+        Balanced::Marketplace.where.first
       end
 
-      def marketplace_exists?
-        !!marketplace_uri
-      end
+      alias mine my_marketplace
 
     end
 
-    # @return [Marketplace]
-    def save
-      marketplace = super
-      @@marketplace_uri = marketplace.uri
-      marketplace
-    end
-
     # Returns an instance representing the marketplace associated with
     # the current API key.
     #
@@ -51,183 +28,8 @@ module Balanced
     def my_marketplace
       self.class.my_marketplace
     end
-    alias mine my_marketplace
-
-    # Create an Account associated with this Marketplace. This account
-    # will have no roles associated with it.
-    #
-    # @return [Account]
-    def create_account options={}
-      email_address = options.fetch(:email_address) { nil }
-      name = options.fetch(:name) { nil }
-      meta = options.fetch(:meta) { nil }
-
-      account_attributes = {
-          :uri => self.accounts_uri,
-          :email_address => email_address,
-          :name => name,
-          :meta => meta
-      }
-
-      account = Account.new account_attributes
-      account.save
-    end
-
-
-    # Create a buyer Account associated with this Marketplace.
-    #
-    # @return [Account]
-    def create_buyer *args
-      warn_on_positional args
 
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      email_address = args[0] || options.fetch(:email_address) { nil }
-      card = args[1] || options.fetch(:card_uri) { options.fetch(:card) { nil} }
-      name = args[2] || options.fetch(:name) { nil }
-      meta = args[3] || options.fetch(:meta) { nil }
-
-      account_attributes = {
-          :uri => self.accounts_uri,
-          :email_address => email_address,
-          :name => name,
-          :meta => meta,
-      }
-
-      if card.respond_to? :keys
-        account_attributes[:card] = card
-      else
-        account_attributes[:card_uri] = card
-      end
-
-      account = Account.new account_attributes
-      account.save
-    end
-
-    # Creates a Merchant Account associated with this Marketplace.
-    #
-    # This method may return 300 if you have not supplied enough information
-    # for Balanced to identify the Merchant. You may re-submit the request
-    # with more information, or redirect the Merchant to the supplied url
-    # so they may manually sign up.
-    #
-    # When you receive a merchant_uri from balanced, just pass it in:
-    #
-    # @example
-    #   Account.create_merchant('bob@example.com', '/v1/TEST-MRxxxx')
-    #
-    # @return [Account]
-    def create_merchant *args
-      warn_on_positional args
-
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      email_address = args[0] || options.fetch(:email_address) { nil }
-      merchant = args[1] || options.fetch(:merchant) { nil }
-      bank_account_uri = args[2] || options.fetch(:bank_account_uri) { nil }
-      name = args[3] || options.fetch(:name) { nil }
-      meta = args[4] || options.fetch(:meta) { nil }
-      bank_account = args[5] || options.fetch(:bank_account) { nil }
-
-      account_attributes = {
-          :uri => self.accounts_uri,
-          :email_address => email_address,
-          :bank_account_uri => bank_account_uri,
-          :name => name,
-          :meta => meta,
-          :bank_account => bank_account
-      }
-
-      if merchant.respond_to? :keys
-        account_attributes[:merchant] = merchant
-      else
-        account_attributes[:merchant_uri] = merchant
-      end
-
-      account = Account.new account_attributes
-      account.save
-    end
-
-    # Creates a BankAccount object tied to this marketplace, for use with
-    # accounts
-    #
-    # @return [BankAccount]
-    def create_bank_account *args
-      warn_on_positional args
-
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      name = args[0] || options.fetch(:name) { }
-      account_number = args[1] || options.fetch(:account_number) { nil }
-      bank_code = args[2] || options.fetch(:bank_code) {
-        options.fetch(:routing_number) {
-          nil
-        }
-      }
-      meta = args[3] || options.fetch(:meta) { nil }
-
-      bank_account = BankAccount.new(
-          :uri => self.bank_accounts_uri,
-          :name => name,
-          :account_number => account_number,
-          :bank_code => bank_code,
-          :meta => meta
-      )
-
-      bank_account.save
-    end
-
-    # Creates a Card object tied to this marketplace, for use with
-    # accounts
-    #
-    # @return [Card]
-    def create_card *args
-      warn_on_positional args
-
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      card_number = args[0] || options.fetch(:card_number) { nil }
-      expiration_month = args[1] || options.fetch(:expiration_month) { nil }
-      expiration_year = args[2] || options.fetch(:expiration_year) { nil }
-      security_code = args[3] || options.fetch(:security_code) { nil }
-      postal_code = args[4] || options.fetch(:postal_code) { nil }
-      name = args[5] || options.fetch(:name) { nil }
-      phone_number = args[6] || options.fetch(:phone_number) { nil }
-      street_address = args[7] || options.fetch(:street_address) { nil }
-      city = args[8] || options.fetch(:city) { nil }
-      country_code = args[9] || options.fetch(:country_code) { nil }
-      meta = args[10] || options.fetch(:meta) { nil }
-
-      card = Card.new(
-          :uri => self.cards_uri,
-          :card_number => card_number,
-          :expiration_month => expiration_month,
-          :expiration_year => expiration_year,
-          :name => name,
-          :security_code => security_code,
-          :street_address => street_address,
-          :city => city,
-          :postal_code => postal_code,
-          :country_code => country_code,
-          :phone_number => phone_number,
-          :meta => meta
-      )
-      card.save
-    end
-
-    def create_customer(options = {})
-      customer = Customer.new(options)
-      customer.save
-    end
-
-    def create_callback *args
-      warn_on_positional args
-
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      url = args[0] || options.fetch(:url) { nil }
-
-      callback = Callback.new(
-          'uri' => self.callbacks_uri,
-          'url' => url
-      )
-      callback.save
-    end
+    alias mine my_marketplace
 
   end
 

data/lib/balanced/resources/order.rb

@@ -0,0 +1,71 @@
+module Balanced
+
+  class Error
+
+    class OrderCancelFailure < Balanced::StandardError;
+
+    end
+
+  end
+
+  class Order
+    include Balanced::Resource
+    include Balanced::HypermediaRegistry
+
+    define_hypermedia_types [:orders]
+
+    def cancel
+      reload
+
+      # shouldn't fail unless there's a network outage
+      # let's just hope there's not (for the sake of time)
+      self.debits.map { |d|
+        begin
+          d.refund rescue d.refunds.to_a
+        end }.flatten
+    end
+
+    alias refund cancel
+
+    def debit_from(options={})
+      Balanced::Utils.assert_required_keys(options, :required => [:source, :amount])
+
+      source = options[:source]
+      amount = options[:amount]
+
+      debit = source.debit(
+          :amount => amount,
+          :order => self.href
+      )
+
+      debit
+    end
+
+    def credit_to(options={})
+      Balanced::Utils.assert_required_keys(options, :required => [:destination, :amount])
+      destination = options[:destination]
+      amount = options[:amount]
+      # should have a way here to disburse more funds to another account, but not required
+      destination.credit(:amount => amount, :order => self.href)
+    end
+
+    private
+
+    def has_initiated_credits?
+      self.credits.total != 0
+    end
+
+    def has_initiated_refunds?
+      self.refunds.total != 0
+    end
+
+    def has_initiated_reversals?
+      self.reversals.total != 0
+    end
+
+    def has_initiated_debits?
+      self.debits.total != 0
+    end
+
+  end
+end

data/lib/balanced/resources/refund.rb

@@ -6,14 +6,9 @@ module Balanced
   #
   class Refund
     include Balanced::Resource
+    include Balanced::HypermediaRegistry
 
-    def initialize attributes = {}
-      Balanced::Utils.stringify_keys! attributes
-      unless attributes.has_key? 'uri'
-        attributes['uri'] = self.class.uri
-      end
-      super attributes
-    end
+    define_hypermedia_types [:refunds]
 
   end
 

data/lib/balanced/resources/resource.rb

@@ -1,95 +1,160 @@
 require File.expand_path('../../pager', __FILE__)
+require File.expand_path('../../utils', __FILE__)
+require 'addressable/template'
+require 'pp'
+
 
 module Balanced
+
   module Resource
+
     attr_accessor :attributes
+    attr_accessor :hyperlinks
+
+    attr_accessor :id
+    attr_accessor :href
+    attr_accessor :links
+
+    def initialize(attributes = {})
+      @attributes = Utils.indifferent_read_access attributes
+      @hyperlinks = {}
+    end
+
+    def id
+      (attributes[:id] ||= nil)
+    end
 
-    def initialize attributes = {}
-      @attributes = attributes
+    def id=(value)
+      attributes[:id] = value
+    end
+
+    def href
+      (attributes[:href] ||= self.class.collection_name)
+    end
+
+    def links
+      (attributes[:links] ||= {})
+    end
+
+    def links=(value)
+      attributes[:links] = value
+    end
+
+    def hydrate(links, meta)
+      # links here is 'marketplaces.events'
+      links.each do |key, uri|
+        # key is 'marketplaces.events'
+        property = key.sub(/.*?\./, '')
+        # property here is events
+        # if marketplace.links is a hash
+        # for each property and uri, we want to set them on the instance
+        # as pagers.
+        #
+        # right?
+        if self.links.include? property
+          link_value = self.links[property]
+          # expands /customers/{marketplaces.owner_customer} to /customers/ACxxxxx
+          template = Addressable::Template.new(uri)
+          uri = template.expand("#{key}" => link_value).to_s
+          @hyperlinks[property] = Balanced::Utils.callable(
+              link_value.nil? ? link_value : lambda { self.class.find(uri) }
+          )
+        else
+          unless uri.nil? || uri.is_a?(Hash)
+            # matches something like '/blah/{class.attribute}/bliakdf'
+            begin
+              match_data = /\{(#{self.class.collection_name}\.(\w+))\}/.match(uri)
+            rescue TypeError => ex
+              puts 'what the fuck'
+              raise ex
+            end
+            unless match_data.nil?
+              attribute_path = match_data[1]
+              attribute_name = match_data[2]
+              template = Addressable::Template.new(uri)
+              uri = template.expand("#{attribute_path}" => @attributes[attribute_name]).to_s
+            end
+          end
+          @hyperlinks[property] = Balanced::Utils.callable(Balanced::Pager.new(uri, {}))
+        end
+      end
     end
 
     # delegate the query to the pager module
 
-    def find *arguments
+    def fetch(*arguments)
       self.class.find *arguments
     end
+    
+    alias find fetch
 
     def save
-      uri = @attributes.delete('uri')
+      href = @attributes.delete('href')
       method = :post
-      if uri.nil?
-        uri = self.class.collection_path
-      elsif !Balanced.is_collection(uri)
+      if href.nil?
+        href = self.class.collection_path
+      elsif !Balanced.is_collection(href)
         method = :put
       end
+
       attributes_to_submit = self.sanitize
-      @response = Balanced.send(method, uri, attributes_to_submit)
+      begin
+        @response = Balanced.send(method, href, attributes_to_submit)
+      rescue Balanced::Error
+        # restore the href on the instance if there was an exception
+        # this will allow us to try to fix any attributes and save again
+        @attributes['href'] = href
+        raise
+      end
+
       reload @response
     end
 
     def sanitize
       to_submit = {}
       @attributes.each do |key, value|
-        if not value.is_a? Balanced::Resource
+        unless value.is_a? Balanced::Resource
           to_submit[key] = value
         end
       end
       to_submit
     end
 
-    def warn_on_positional args
-      msg = <<-WARNING
-      Called from: #{caller[1]}
-      #############################################################
-      #   WARNING! WARNING! WARNING! WARNING! WARNING! WARNING!   #
-      #############################################################
-
-      Using positional arguments is **DEPRECATED**. Please use the
-      keyword options pattern instead. Version __0.7.0__ of the
-      Ruby client will not support positional arguments.
-
-      If you need help, please hop on irc.freenode.net #balanced
-      or contact support@balancedpayments.com
-      WARNING
-      # warn if [...] otherwise, it's ok if it's: [], [{}] or [{...}]
-      unless (args.size == 1 and args.last.is_a? Hash) or (args.size == 0)
-        warn msg
-      end
-    end
-
     def response
       @response
     end
-    private :response
 
-    def destroy
-      Balanced.delete @attributes[:uri]
-    end
+    private :response
 
     def unstore
-      destroy
+      Balanced.unstore @attributes[:href]
     end
+    alias_method :destroy, :unstore
 
-    def reload the_response = nil
+    def reload(the_response = nil)
       if the_response
         return if the_response.body.to_s.length.zero?
         fresh = self.class.construct_from_response the_response.body
       else
-        fresh = self.find(@attributes[:uri])
+        fresh = self.find(@attributes[:href])
       end
       fresh and copy_from fresh
       self
     end
 
-    def copy_from other
+    def copy_from(other)
       other.instance_variables.each do |ivar|
         instance_variable_set ivar, other.instance_variable_get(ivar)
       end
     end
 
     def method_missing(method, *args, &block)
+      if @attributes.has_key?(method.to_s)
+        return @attributes[method.to_s]
+      end
+
       case method.to_s
-        when /(.+)\=$/
+        when /(.+)=$/
           attr = method.to_s.chop
           @attributes[attr] = args[0]
         else
@@ -105,29 +170,36 @@ module Balanced
           # method requests that are essentially #{method}_uri.
           #
           # This solves the acute problem, for now.
-          if @attributes.has_key? "#{method}_uri"
-            value = @attributes["#{method}_uri"]
-            values_class = Balanced.from_uri(value)
-            # if uri is a collection -> this would definitely be if
-            # it ends in a symbol then we should allow a lazy executor of
-            # the query pager
-            if Balanced.is_collection(value)
-              pager = Balanced::Pager.new value, {}
-              return pager.to_a
-            else
-              return values_class.find(value)
-            end
+          if @hyperlinks.has_key? "#{method}"
+            value = @hyperlinks["#{method}"]
+            result = value.call
+            return result
           else
             super
           end
       end
     end
-    
+
+    if RUBY_VERSION < '1.9'
+      def respond_to?(method_name, include_private=false)
+        does_resource_respond_to?(method_name) || super
+      end
+    else
+      def respond_to_missing?(method_name, include_private=false)
+        does_resource_respond_to?(method_name) || super
+      end
+    end
+
+    def does_resource_respond_to?(method_name)
+      @attributes.has_key?(method_name.to_s) or @hyperlinks.has_key?(method_name.to_s)
+    end
+
     def self.included(base)
       base.extend ClassMethods
     end
 
     module ClassMethods
+
       def resource_name
         Utils.demodulize name
       end
@@ -137,86 +209,77 @@ module Balanced
       end
 
       def collection_path
-        ["/v#{Balanced.config[:version]}", collection_name].compact.join '/'
+        # this is to just support version1  stuff, but in reality, if we get here
+        # we should throw an exception since we do not want to use v1 ever.
+        if Balanced.config[:version] == '1'
+          # XXX: we should raise an exception if we get here.
+          ["/v#{Balanced.config[:version]}", collection_name].compact.join '/'
+        else
+          collection_name
+        end
       end
 
-      def member_name
-        Utils.underscore resource_name
+      def href
+        collection_path
       end
 
-      # Returns the resource URI for a given class.
-      #
-      # @example A Balanced::Account resource
-      #   Balanced::Account.uri # => "/v1/marketplaces/TEST-MP72zVdg2j9IiqRffW9lczRZ/accounts"
-      #
-      # @return [String] the uri of the instance or the class
-      def uri
-        # the uri of a particular resource depends if there's a marketplace
-        # created or not. if there's a marketplace, then all resources have their
-        # own uri from there and the top level ones. if there's not a marketplace
-        #
-        #    if there's an api key, then the merchant is available
-        #    if there's no api key, the only resources exposed are purely top level
-        if self == Balanced::Merchant || self == Balanced::Marketplace || self == Balanced::ApiKey
-          collection_path
-        else
-          unless Balanced::Marketplace.marketplace_exists?
-            raise Balanced::StandardError, "#{self.name} is nested under a marketplace, which is not created or configured."
-          end
-
-          Balanced::Marketplace.marketplace_uri + "/#{collection_name}"
-        end
+      def member_name
+        Utils.underscore resource_name
       end
 
-      def construct_from_response payload
-        payload = Balanced::Utils.hash_with_indifferent_read_access payload
-        return payload if payload[:uri].nil?
-        klass = Balanced.from_uri(payload[:uri])
-        instance = klass.new payload
+      def construct_from_response(payload)
+        payload = Balanced::Utils.indifferent_read_access payload
 
-        # http://stackoverflow.com/a/2495650/133514
-        instance_eigen = class << instance; self; end
+        links = payload.delete('links') || {}
+        meta = payload.delete('meta') || {}
 
-        payload.each do |name, value|
+        if payload.length > 1
+          raise 'NOT SUPPORTED YET'
+        end
 
-          # here is where our interpretations will begin.
-          # if the value is a sub-resource, lets instantiate the class
-          # and set it correctly
-          if value.instance_of? Hash and value.has_key? 'uri'
-            value = construct_from_response value
+        instance = nil
+        # the remaining keys here are just hypermedia resources
+        payload.each do |key, value|
+          # > If the length of an array at a resource key is greater than one,
+          #   the value represents a list of documents.
+          if value.length > 1
+            # key is a collection, this should never happen
+            raise 'This should basically never happen'
           end
-
-           # Get attribute
-          instance.class.send(:define_method, name, proc{@attributes[name]})
-           # Set attribute
-          instance.class.send(:define_method, "#{name}=",  proc{ |value| @attributes[name] = value })
-           # Is attribute present?
-          instance.class.send(:define_method, "#{name}?", proc{ !!@attributes[name] })
-
-          instance.send("#{name}=".to_s, value)
+          # > Singular resources are represented as JSON objects. However,
+          #   they are still wrapped inside an array:
+          resource_body = value.first
+          cls = Balanced.from_hypermedia_registry(key)
+          instance = cls.new resource_body
+          instance.hydrate(links, meta)
         end
         instance
       end
 
-      def find *arguments
-        scope   = arguments.slice!(0)
+      def fetch(*arguments)
+        scope = arguments.slice!(0)
         options = arguments.slice!(0) || {}
         case scope
-          when :all   then all(options)
-          when :first then paginate(options).first
+          when :all then
+            all(options)
+          when :first then
+            paginate(options).first
           else
             response = Balanced.get scope, options
             construct_from_response response.body
         end
       end
 
-      def paginate options = {}
-        Balanced::Pager.new uri, options
+      alias find fetch
+      
+      def paginate(options = {})
+        Balanced::Pager.new href, options
       end
+
       alias scoped paginate
-      alias where  paginate
+      alias where paginate
 
-      def all options = {}
+      def all(options = {})
         pager = paginate(options)
         pager.to_a
       end