balanced-ach 0.1

data/lib/balanced/pager.rb

@@ -0,0 +1,201 @@
+require "cgi"
+
+module Balanced
+  class Pager
+    DEFAULT_SEP = /[&;] */n
+    DEFAULT_LIMIT = 10
+
+    include Enumerable
+
+    # A pager for paginating through resource records.
+    def initialize uri, options = {}
+      @uri = uri
+      @options = options
+      @page = nil
+      @resource_class = nil
+    end
+
+    def resource_class
+      return @resource_class unless @resource_class.nil?
+      load! unless @page
+      @resource_class = Balanced.from_uri items.first[:uri]
+    end
+
+    def first
+      load! unless @page
+      items.first.nil? ? nil : resource_class.construct_from_response(items.first)
+    end
+
+    def total
+      load! unless @page
+      @page[:total]
+    end
+
+    def limit
+      load! unless @page
+      @page[:limit]
+    end
+    alias limit_value limit
+
+    def offset
+      load! unless @page
+      @page[:offset]
+    end
+    alias offset_value offset
+
+    def items
+      load! unless @page
+      @page[:items]
+    end
+
+    def current_page
+      (offset / limit) + 1
+    end
+
+    def num_pages
+      num = total / limit
+      num += 1 if total % limit > 0
+      num
+    end
+
+    # @return [Array] Iterates through the current page of records.
+    # @yield [record]
+    def each
+      return enum_for :each unless block_given?
+
+      load! unless @page
+      loop do
+        @page[:items].each do |r|
+          yield resource_class.construct_from_response r
+        end
+        raise StopIteration if @page[:next_uri].nil?
+        self.next
+      end
+    end
+
+    # @return [nil]
+    # @see Resource.find_each
+    # @yield [record]
+    def find_each
+      return enum_for :find_each unless block_given?
+      begin
+        each { |record| yield record }
+      end while self.next
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    #   the next page.
+    def next
+      load! unless @page
+      next_uri = @page[:next_uri]
+      load_from next_uri, nil unless next_uri.nil?
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    #   the previous page.
+    def prev
+      load! unless @page
+      prev_uri = @page[:prev_uri]
+      load_from prev_uri, nil unless prev_uri.nil?
+    end
+
+    # @return [Array, nil] Refreshes the pager's collection of records with
+    #   the first page.
+    def start
+      load! unless @page
+      first_page = @page[:first_page]
+      load_from first_page, nil unless first_page.nil?
+    end
+
+    # @return [Array, nil] Load (or reload) the pager's collection from the
+    #   original, supplied options.
+    def load!
+      load_from @uri, @options
+    end
+    alias reload load!
+
+    # @return [Pager] Duplicates the pager, updating it with the options
+    #   supplied. Useful for resource scopes.
+    # @see #initialize
+    def paginate options = {}
+      dup.instance_eval {
+        @page = nil
+        @options.update options and self
+      }
+    end
+    alias scoped paginate
+    alias where  paginate
+
+    def all options = {}
+      paginate(options).to_a
+    end
+
+    def find uri
+      if resource_class.respond_to? :find
+        raise NoMethodError,
+            "#find must be called on #{resource_class} directly"
+      end
+
+      resource_class.find uri
+    end
+
+
+    private
+
+    def load_from uri, params
+      parsed_uri = URI.parse(uri)
+
+      params ||= {}
+      params = adjust_pagination_params(params)
+
+      unless parsed_uri.query.nil?
+        # The reason we don't use CGI::parse here is because
+        # the balanced api currently can't handle variable[]=value.
+        # Faraday ends up encoding a simple query string like:
+        #    {"limit"=>["10"], "offset"=>["0"]}
+        # to limit[]=10&offset[]=0 and that's cool, but
+        # we have to make sure balanced supports it.
+        query_params = parse_query(parsed_uri.query)
+        params.merge! query_params
+        parsed_uri.query = nil
+      end
+
+      response = Balanced.get parsed_uri.to_s, params
+      @page = Balanced::Utils.hash_with_indifferent_read_access response.body
+      @uri = @page[:uri]
+    end
+
+    def adjust_pagination_params(original)
+      adjusted = original.dup
+      per = adjusted.delete(:per)
+      adjusted[:limit] = per unless per.nil?
+      page = adjusted.delete(:page)
+      adjusted[:offset] = (adjusted[:limit] || DEFAULT_LIMIT) * ([page, 1].max - 1) unless page.nil?
+      adjusted
+    end
+
+    # Stolen from Mongrel, with some small modifications:
+    # Parses a query string by breaking it up at the '&'
+    # and ';' characters.  You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;').
+    def parse_query(qs, d = nil)
+      params = {}
+
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |x| CGI::unescape(x) }
+        if (cur = params[k])
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+
+      params
+    end
+  end
+end

data/lib/balanced/resources.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), "balanced", "resources")
+require "resource"
+require "bank_account"
+require "credit"
+require "debit"

data/lib/balanced/resources/bank_account.rb

@@ -0,0 +1,36 @@
+module Balanced
+  class BankAccount
+    include Balanced::Resource
+
+    def initialize attributes = {}
+      Balanced::Utils.stringify_keys! attributes
+      unless attributes.has_key? 'uri'
+        attributes['uri'] = self.class.uri
+      end
+      super attributes
+    end
+
+    def debit params
+      amount = params.fetch(:amount) {nil}
+      if amount.nil?
+        raise "amount is required"
+      end
+      response = Balanced.post(self.debits_uri, :amount => amount)
+      self.class.construct_from_response response.body
+    end
+
+    def credit params
+      amount = params.fetch(:amount) {nil}
+      if amount.nil?
+        raise "amount is required"
+      end
+      response = Balanced.post(self.credits_uri, :amount => amount)
+      self.class.construct_from_response response.body
+    end
+
+    def unstore
+      Balanced.delete(self.uri)
+    end
+
+  end
+end

data/lib/balanced/resources/credit.rb

@@ -0,0 +1,20 @@
+module Balanced
+  # A Credit represents a transfer of funds from your Marketplace's
+  # escrow account to a Merchant's Account within your Marketplace.
+  #
+  # By default, a Credit is sent to the most recently added funding
+  # destination associated with an Account. You may specify a specific
+  # funding source.
+  #
+  class Credit
+    include Balanced::Resource
+    def initialize attributes = {}
+      Balanced::Utils.stringify_keys! attributes
+      unless attributes.has_key? 'uri'
+        attributes['uri'] = self.class.uri
+      end
+      super attributes
+    end
+  end
+end
+

data/lib/balanced/resources/debit.rb

@@ -0,0 +1,27 @@
+module Balanced
+  # A Debit represents a transfer of funds from a buyer's Account to your
+  # Marketplace's escrow account.
+  #
+  # A Debit may be created directly, or it will be created as a side-effect
+  # of capturing a Hold. If you create a Debit directly it will implicitly
+  # create the associated Hold if the funding source supports this.
+  #
+  # If no Hold is specified the Debit will by default be created using the
+  # most recently added funding source associated with the Account. You
+  # cannot change the funding source between creating a Hold and capturing
+  # it.
+  #
+  class Debit
+    include Balanced::Resource
+
+    def initialize attributes = {}
+      Balanced::Utils.stringify_keys! attributes
+      unless attributes.has_key? 'uri'
+        attributes['uri'] = self.class.uri
+      end
+      super attributes
+    end
+
+  end
+end
+

data/lib/balanced/resources/resource.rb

@@ -0,0 +1,158 @@
+require_relative "../pager"
+
+
+module Balanced
+  module Resource
+    attr_accessor :attributes
+
+    def initialize attributes = {}
+      @attributes = attributes
+    end
+
+    # delegate the query to the pager module
+
+    def find *arguments
+      self.class.find *arguments
+    end
+
+    def save
+      uri = @attributes.delete('uri')
+      method = :post
+      if uri.nil?
+        uri = self.class.collection_path
+      elsif !Balanced.is_collection(uri)
+        method = :put
+      end
+      @response = Balanced.send(method, uri, self.attributes)
+      reload @response
+    end
+
+    def response
+      @response
+    end
+    private :response
+
+    def destroy
+      Balanced.delete @attributes[:uri]
+    end
+
+    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])
+      end
+      fresh and copy_from fresh
+      self
+    end
+
+    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)
+      case method
+        when /(.+)\=$/
+          attr = method.to_s.chop
+          @attributes[attr] = args[0]
+        else
+          super
+      end
+    end
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def resource_name
+      Utils.demodulize name
+    end
+
+    def collection_name
+      Utils.pluralize Utils.underscore(resource_name)
+    end
+
+    def collection_path
+      ["/#{Balanced.config[:version]}", collection_name].compact.join '/'
+    end
+
+    def member_name
+      Utils.underscore resource_name
+    end
+
+    def uri
+      collection_path
+    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
+      payload.each do |name, value|
+        klass.class_eval {
+          attr_accessor name.to_s
+        }
+        # 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
+        elsif name =~ /_uri$/
+          modified_name = name.sub(/_uri$/, '')
+          klass.instance_eval {
+            define_method(modified_name) {
+              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 = Pager.new value, {}
+                pager.to_a
+              else
+                values_class.find(value)
+              end
+            }
+          }
+        end
+
+        instance.class.instance_eval {
+          define_method(name) { @attributes[name] }                       # Get.
+          define_method("#{name}=") { |value| @attributes[name] = value } # Set.
+          define_method("#{name}?") { !!@attributes[name].nil? }               # Present.
+        }
+        instance.send("#{name}=".to_s, value)
+      end
+      instance
+    end
+
+    def find *arguments
+      scope   = arguments.slice!(0)
+      options = arguments.slice!(0) || {}
+      case scope
+        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 = {}
+      Pager.new uri, options
+    end
+    alias scoped paginate
+    alias where  paginate
+
+    def all options = {}
+      pager = paginate(options)
+      pager.to_a
+    end
+
+  end
+
+  end
+end
+