paid 1.0.1 → 1.0.2

data/lib/paid/api_resource.rb

@@ -1,16 +1,138 @@
 module Paid
-  class APIResource < APIClass
-    attribute :id
-    attribute :object
+  class APIResource
 
-    api_instance_method :refresh, :get, :constructor => :self
+    class << self
+      # The default :id method is deprecated and isn't useful to us
+      if method_defined?(:id)
+        undef :id
+      end
+    end
+
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    attr_reader :api_method
+    attr_reader :json
+
+    def initialize(json=nil, api_method=nil)
+      refresh_from(json)
+    end
+
+    def refresh_from(json={}, api_method=nil)
+      unless json.is_a?(Hash)
+        json = { :id => json }
+      end
+      json = Util.symbolize_keys(json)
+
+      # Clear or write over any old data
+      clear_api_attributes
+      @api_method = api_method
+      @json = Util.sorta_deep_clone(json)
+
+      # Use json (not the @json, the cloned copy)
+      json.each do |k, v|
+        if self.class.api_attribute_names.include?(k.to_sym)
+          instance_variable_set("@#{k}", determine_api_attribute_value(k, v))
+        end
+      end
+      self
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> Attributes: " + JSON.pretty_generate(inspect_api_attributes)
+    end
+
+    def inspect_nested
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}>"
+    end
+
+    def to_json(*args)
+      JSON.generate(api_attributes)
+    end
+
+    def self.api_attribute_names
+      @api_attributes.map(&:first)
+    end
+
+    def api_attributes
+      ret = {}
+      self.class.api_attribute_names.each do |attribute|
+        ret[attribute] = self.send(attribute)
+      end
+      ret
+    end
+
+    def inspect_api_attributes
+      ret = {}
+      api_attributes.each do |k, v|
+        if v.is_a?(APIResource)
+          ret[k] = v.inspect_nested
+        else
+          ret[k] = v
+        end
+      end
+      ret
+    end
+
+    # TODO(joncalhoun): Make this work for nested class construction.
+    def changed_api_attributes
+      ret = {}
+      self.api_attributes.each do |name, value|
+        if @json[name] != value
+          ret[name] = value
+        end
+      end
+      ret
+    end
+
+    def clear_api_attributes
+      self.class.api_attribute_names.each do |name|
+        instance_variable_set("@#{name}", nil)
+      end
+    end
+
+    def self.determine_api_attribute_value(name, raw_value)
+      if @api_attributes[name] && @api_attributes[name].has_key?(:constructor)
+        klass = Util.constantize(@api_attributes[name][:constructor])
+        if(klass.respond_to?(:construct))
+          klass.construct(raw_value)
+        else
+          klass.new(raw_value)
+        end
+      else
+        raw_value
+      end
+    end
+    def determine_api_attribute_value(name, raw_value)
+      self.class.determine_api_attribute_value(name, raw_value)
+    end
+
+
+    def self.api_subclasses
+      return @api_subclasses ||= Set.new
+    end
+
+    def self.api_subclass_fetch(name)
+      @api_subclasses_hash ||= {}
+      if @api_subclasses_hash.has_key?(name)
+        @api_subclasses_hash[name]
+      end
+    end
+
+    def self.register_api_subclass(subclass, name=nil)
+      @api_subclasses ||= Set.new
+      @api_subclasses << subclass
 
-    def path(base=self.class.path)
-      unless id
-        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has an invalid ID: #{id.inspect}", 'id')
+      unless name.nil?
+        @api_subclasses_hash ||= {}
+        @api_subclasses_hash[name] = subclass
       end
-      "#{base}/#{id}"
     end
 
+    @api_attributes = {}
   end
 end

data/lib/paid/customer.rb

@@ -1,44 +1,108 @@
 module Paid
   class Customer < APIResource
-    # attributes :id and :object inherited from APIResource
-    attribute :name
-    attribute :email
-    attribute :description
-    attribute :external_id
-    attribute :phone
-    attribute :address_line1
-    attribute :address_line2
-    attribute :address_city
-    attribute :address_state
-    attribute :address_zip
-    attribute :allow_ach
-    attribute :allow_wire
-    attribute :allow_check
-    attribute :allow_credit_card
-    attribute :terms
-    attribute :billing_type
-    attribute :billing_cycle
-    attribute :stripe_customer_id
-
-    api_class_method :all, :get, :constructor => APIList.constructor(Customer)
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
-    api_class_method :create, :post
-    api_class_method :by_external_id, :get, ":path/by_external_id", :arguments => [:external_id]
-
-    api_instance_method :save, :put, :default_params => :changed_attributes
-    api_instance_method :generate_invoice, :post, ":path/generate_invoice", :constructor => Invoice
-
-    api_instance_method :invoices, :get, Invoice.path, :default_params => :customer_id_hash, :constructor => APIList.constructor(Invoice)
-    api_instance_method :transactions, :get, Transaction.path, :default_params => :customer_id_hash, :constructor => APIList.constructor(Transaction)
-
-    def self.path
-      "/v0/customers"
-    end
-
-    def customer_id_hash
-      { :customer => self.id }
-    end
-
-    APIClass.register_subclass(self, "customer")
+    attr_reader :id
+    attr_reader :object
+    attr_accessor :name
+    attr_accessor :email
+    attr_accessor :description
+    attr_accessor :external_id
+    attr_accessor :phone
+    attr_accessor :address_line1
+    attr_accessor :address_line2
+    attr_accessor :address_city
+    attr_accessor :address_state
+    attr_accessor :address_zip
+    attr_accessor :allow_ach
+    attr_accessor :allow_wire
+    attr_accessor :allow_check
+    attr_accessor :allow_credit_card
+    attr_accessor :terms
+    attr_accessor :billing_type
+    attr_accessor :billing_cycle
+    attr_accessor :stripe_customer_id
+
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/customers", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
+
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/customers/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def self.by_external_id(external_id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :external_id => external_id
+      })
+      method = APIMethod.new(:get, "/customers/by_external_id", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def self.create(params={}, headers={})
+      method = APIMethod.new(:post, "/customers", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/customers/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
+
+    def save(params={}, headers={})
+      params = ParamsBuilder.merge(params, changed_api_attributes)
+      method = APIMethod.new(:put, "/customers/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
+
+    def generate_invoice(params={}, headers={})
+      method = APIMethod.new(:post, "/customers/:id/generate_invoice", params, headers, self)
+      Util.constantize(:Invoice).new(method.execute, method)
+    end
+
+    def invoices(params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :customer => self.id,
+      })
+      method = APIMethod.new(:get, "/invoices", params, headers, self)
+      APIList.new(:Invoice, method.execute, method)
+    end
+
+    def transactions(params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :customer => self.id,
+      })
+      method = APIMethod.new(:get, "/transactions", params, headers, self)
+      APIList.new(:Transaction, method.execute, method)
+    end
+
+
+    # Everything below here is used behind the scenes.
+    APIResource.register_api_subclass(self, "customer")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :name => nil,
+      :email => nil,
+      :description => nil,
+      :external_id => nil,
+      :phone => nil,
+      :address_line1 => nil,
+      :address_line2 => nil,
+      :address_city => nil,
+      :address_state => nil,
+      :address_zip => nil,
+      :allow_ach => nil,
+      :allow_wire => nil,
+      :allow_check => nil,
+      :allow_credit_card => nil,
+      :terms => nil,
+      :billing_type => nil,
+      :billing_cycle => nil,
+      :stripe_customer_id => nil
+    }
   end
 end

data/lib/paid/errors/api_connection_error.rb

@@ -1,4 +1,4 @@
 module Paid
-  class APIConnectionError < PaidError
+  class APIConnectionError < APIError
   end
 end

data/lib/paid/errors/api_error.rb

@@ -1,10 +1,32 @@
 module Paid
   class APIError < PaidError
+    attr_reader :api_method
 
-    def self.generic(rcode, rbody)
-      self.new("Invalid response object from API: #{rbody.inspect} " +
-               "(HTTP response code was #{rcode})", rcode, rbody)
+    def initialize(message=nil, api_method=nil)
+      @message = message
+      @api_method = api_method
     end
 
+    def code
+      @api_method.response_code if @api_method
+    end
+
+    def body
+      @api_method.response_body if @api_method
+    end
+
+    def json
+      begin
+        @api_method.response_json if @api_method
+      rescue APIError
+        nil
+      end
+    end
+
+    def to_s
+      prefix = code.nil? ? "" : "(Status #{code}) "
+      "#{prefix}#{@message}"
+    end
   end
 end
+

data/lib/paid/errors/authentication_error.rb

@@ -1,4 +1,4 @@
 module Paid
-  class AuthenticationError < PaidError
+  class AuthenticationError < APIError
   end
 end

data/lib/paid/errors/paid_error.rb

@@ -1,20 +1,13 @@
 module Paid
   class PaidError < 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)
+    def initialize(message=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}"
+      "#{@message}"
     end
   end
 end

data/lib/paid/event.rb

@@ -1,26 +1,37 @@
 module Paid
   class Event < APIResource
-    class Data
-      def self.construct(json={})
-        return nil if json.nil?
-        klass = APIClass.subclass_fetch(json[:object])
-        klass.construct(json)
-      end
-    end
-
-    # attributes :id and :object inherited from APIResource
-    attribute :created_at
-    attribute :type
-    attribute :data, Data
+    attr_reader :id
+    attr_reader :object
+    attr_reader :created_at
+    attr_reader :type
+    attr_reader :data
 
-    api_class_method :all, :get, :constructor => APIList.constructor(Event)
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/events", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
 
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/events/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    def self.path
-      "/v0/events"
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/events/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "event")
+    # Everything below here is used behind the scenes.
+    APIResource.register_api_subclass(self, "event")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :created_at => { :readonly => true },
+      :type => { :readonly => true },
+      :data => { :constructor => :EventData, :readonly => true },
+    }
   end
 end

data/lib/paid/event_data.rb

@@ -0,0 +1,10 @@
+module Paid
+  class EventData
+
+    def self.construct(json={})
+      return nil if json.nil?
+      return APIResource.api_subclass_fetch(json[:object]).new(json)
+    end
+
+  end
+end

data/lib/paid/headers_builder.rb

@@ -0,0 +1,75 @@
+module Paid
+  module HeadersBuilder
+
+    def self.build(headers, api_key=nil, auth_key=nil)
+      headers ||= {}
+      if auth_key
+        temp = default_headers.merge(custom_auth_header(auth_key, api_key))
+      else
+        temp = default_headers.merge(basic_auth_header(api_key))
+      end
+      temp.merge(headers)
+    end
+
+    def self.default_headers
+      headers = {
+        :user_agent => "Paid/#{Paid.api_version} RubyBindings/#{Paid::VERSION}",
+        :content_type => 'application/x-www-form-urlencoded'
+      }
+
+      begin
+        headers.update(:x_paid_client_user_agent => JSON.generate(user_agent))
+      rescue => e
+        headers.update(:x_paid_client_raw_user_agent => user_agent.inspect,
+                       :error => "#{e} (#{e.class})")
+      end
+      headers
+    end
+
+    def self.custom_auth_header(key, api_key)
+      unless api_key
+        raise AuthenticationError.new('No API key provided. Set your API key using "Paid.api_key = <API-KEY>".')
+      end
+
+      {
+        key => api_key,
+      }
+    end
+
+    def self.basic_auth_header(api_key)
+      unless api_key
+        raise AuthenticationError.new('No API key provided. Set your API key using "Paid.api_key = <API-KEY>".')
+      end
+
+      base_64_key = Base64.encode64("#{api_key}:")
+      {
+        "Authorization" => "Basic #{base_64_key}",
+      }
+    end
+
+    def self.user_agent
+      lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+      {
+        :bindings_version => Paid::VERSION,
+        :lang => 'ruby',
+        :lang_version => lang_version,
+        :platform => RUBY_PLATFORM,
+        :publisher => 'paid',
+        :uname => get_uname
+      }
+    end
+
+    def self.get_uname
+      `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+    rescue Errno::ENOMEM => ex # couldn't create subprocess
+      "uname lookup failed"
+    end
+
+  end
+end
+
+
+
+
+