dnsimple 2.2.0 → 3.0.0.pre.beta1

data/lib/dnsimple/client/clients.rb

@@ -1,14 +1,9 @@
 module Dnsimple
   class Client
 
-    # @return [Dnsimple::Client::CertificatesService] The certificate-related API proxy.
-    def certificates
-      @services[:certificates] ||= Client::CertificatesService.new(self)
-    end
-
     # @return [Dnsimple::Client::ContactsService] The contact-related API proxy.
     def contacts
-      @services[:contacts] ||= Client::ContactsService.new(self)
+      @services[:domains] ||= Client::ContactsService.new(self)
     end
 
     # @return [Dnsimple::Client::DomainsService] The domain-related API proxy.
@@ -16,9 +11,14 @@ module Dnsimple
       @services[:domains] ||= Client::DomainsService.new(self)
     end
 
-    # @return [Dnsimple::Client::NameServersService] The name server-related API proxy.
-    def name_servers
-      @services[:name_servers] ||= Client::NameServersService.new(self)
+    # @return [Dnsimple::Client::IdentityService] The identity-related API proxy.
+    def identity
+      @services[:auth] ||= Client::IdentityService.new(self)
+    end
+
+    # @return [Dnsimple::Client::OauthService] The oauth-related API proxy.
+    def oauth
+      @services[:oauth] ||= Client::OauthService.new(self)
     end
 
     # @return [Dnsimple::Client::RegistrarService] The registrar-related API proxy.
@@ -26,100 +26,124 @@ module Dnsimple
       @services[:registrar] ||= Client::RegistrarService.new(self)
     end
 
-    # @return [Dnsimple::Client::ServicesService] The service-related API proxy.
-    def services
-      @services[:services] ||= Client::ServicesService.new(self)
+    # @return [Dnsimple::Client::TldsService] The tld-related API proxy.
+    def tlds
+      @services[:tlds] ||= Client::TldsService.new(self)
     end
 
-    # @return [Dnsimple::Client::TemplatesService] The template-related API proxy.
-    def templates
-      @services[:templates] ||= Client::TemplatesService.new(self)
+    # @return [Dnsimple::Client::ZonesService] The zone-related API proxy.
+    def zones
+      @services[:zones] ||= Client::ZonesService.new(self)
     end
 
-    # @return [Dnsimple::Client::UsersService] The user-related API proxy.
-    def users
-      @services[:users] ||= Client::UsersService.new(self)
+    # @return [Dnsimple::Client::WebhooksService] The webhooks-related API proxy.
+    def webhooks
+      @services[:webhooks] ||= Client::WebhooksService.new(self)
     end
 
 
+    # @!class Struct
     class ClientService < ::Struct.new(:client)
-    end
 
+      # Internal helper that loops over a paginated response and returns all the records in the collection.
+      #
+      # @api private
+      #
+      # @param  [Symbol] method The client method to execute
+      # @param  [Array] args The args to call the method with
+      # @return [Dnsimple::CollectionResponse]
+      def paginate(method, *args)
+        current_page = 0
+        total_pages = nil
+        collection = []
+        options = args.pop
+        response = nil
+
+        begin
+          current_page += 1
+          query = Extra.deep_merge(options, query: { page: current_page, per_page: 100 })
+
+          response = send(method, *(args + [query]))
+          total_pages ||= response.total_pages
+          collection.concat(response.data)
+        end while current_page < total_pages
 
-    require 'dnsimple/client/certificates'
+        CollectionResponse.new(response.http_response, collection)
+      end
 
-    class CertificatesService < ClientService
-      include Client::Certificates
     end
 
 
-    require 'dnsimple/client/contacts'
+    require_relative 'contacts'
 
     class ContactsService < ClientService
       include Client::Contacts
     end
 
 
-    require 'dnsimple/client/domains'
-    require 'dnsimple/client/domains_records'
-    require 'dnsimple/client/domains_autorenewal'
-    require 'dnsimple/client/domains_privacy'
-    require 'dnsimple/client/domains_sharing'
-    require 'dnsimple/client/domains_forwards'
-    require 'dnsimple/client/domains_zones'
+    require_relative 'domains'
+    require_relative 'domains_email_forwards'
 
     class DomainsService < ClientService
       include Client::Domains
-      include Client::DomainsRecords
-      include Client::DomainsAutorenewal
-      include Client::DomainsPrivacy
-      include Client::DomainsSharing
-      include Client::DomainsForwards
-      include Client::DomainsZones
+      include Client::DomainsEmailForwards
     end
 
 
-    require 'dnsimple/client/name_servers'
-    require 'dnsimple/client/vanity_name_servers'
+    require_relative 'identity'
 
-    class NameServersService < ClientService
-      include Client::NameServers
-      include Client::VanityNameServers
+    class IdentityService < ClientService
+      include Client::Identity
     end
 
 
-    require 'dnsimple/client/registrar'
+    require_relative 'oauth'
+
+    class OauthService < ClientService
+      include Client::Oauth
+    end
+
+
+    require_relative 'registrar'
+    require_relative 'registrar_auto_renewal'
+    require_relative 'registrar_whois_privacy'
 
     class RegistrarService < ClientService
       include Client::Registrar
+      include Client::RegistrarAutoRenewal
+      include Client::RegistrarWhoisPrivacy
     end
 
 
-    require 'dnsimple/client/services'
-    require 'dnsimple/client/services_domains'
+    require_relative 'tlds'
 
-    class ServicesService < ClientService
-      include Client::Services
-      include Client::ServicesDomains
+    class TldsService < ClientService
+      include Client::Tlds
     end
 
 
-    require 'dnsimple/client/templates'
-    require 'dnsimple/client/templates_domains'
-    require 'dnsimple/client/templates_records'
+    require_relative 'zones'
+    require_relative 'zones_records'
 
-    class TemplatesService < ClientService
-      include Client::Templates
-      include Client::TemplatesDomains
-      include Client::TemplatesRecords
+    class ZonesService < ClientService
+      include Client::Zones
+      include Client::ZonesRecords
     end
 
+    require_relative 'webhooks'
 
-    require 'dnsimple/client/users'
-
-    class UsersService < ClientService
-      include Client::Users
+    class WebhooksService < ClientService
+      include Client::Webhooks
     end
 
   end
+
+  # This module exposes static helpers for the API v2.
+  #
+  # Compared to the full, extended API methods provided by the various client services,
+  # these static methods return directly the underlying data objects.
+  # Therefore, it's not possible to access response metadata such as throttling or pagination info.
+  module V2
+    extend Client::Identity::StaticHelpers
+  end
 end

data/lib/dnsimple/client/contacts.rb

@@ -4,66 +4,99 @@ module Dnsimple
 
       # Lists the contacts in the account.
       #
-      # @see http://developer.dnsimple.com/v1/contacts/#list
+      # @see https://developer.dnsimple.com/v2/contacts/#list
+      # @see #all_contacts
       #
-      # @return [Array<Struct::Contact>]
+      # @example List contacts in the first page
+      #   client.contacts.list(1010)
       #
-      # @raise  [RequestError] When the request fails.
-      def contacts(options = {})
-        response = client.get(Client.versioned("/contacts"), options)
+      # @example List contacts, provide a specific page
+      #   client.contacts.list(1010, query: { page: 2 })
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [Hash] options the filtering and sorting option
+      # @return [Dnsimple::PaginatedResponse<Dnsimple::Struct::Contact>]
+      #
+      # @raise  [Dnsimple::RequestError]
+      def contacts(account_id, options = {})
+        response = client.get(Client.versioned("/%s/contacts" % [account_id]), options)
 
-        response.map { |r| Struct::Contact.new(r["contact"]) }
+        Dnsimple::PaginatedResponse.new(response, response["data"].map { |r| Struct::Contact.new(r) })
       end
       alias :list :contacts
       alias :list_contacts :contacts
 
+      # Lists ALL the contacts in the account.
+      #
+      # This method is similar to {#contacts}, but instead of returning the results of a specific page
+      # it iterates all the pages and returns the entire collection.
+      #
+      # Please use this method carefully, as fetching the entire collection will increase the number of requests
+      # you send to the API server and you may eventually risk to hit the throttle limit.
+      #
+      # @see https://developer.dnsimple.com/v2/contacts/#list
+      # @see #contacts
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [Hash] options the filtering and sorting option
+      # @return [Dnsimple::CollectionResponse<Dnsimple::Struct::Contact>]
+      #
+      # @raise  [Dnsimple::RequestError]
+      def all_contacts(account_id, options = {})
+        paginate(:contacts, account_id, options)
+      end
+      alias :all :all_contacts
+
       # Creates a contact in the account.
       #
-      # @see http://developer.dnsimple.com/v1/contacts/#create
+      # @see https://developer.dnsimple.com/v2/contacts/#create
       #
+      # @param  [Fixnum] account_id the account ID
       # @param  [Hash] attributes
-      # @return [Struct::Contact]
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::Contact>]
       #
-      # @raise  [RequestError] When the request fails.
-      def create_contact(attributes = {}, options = {})
+      # @raise  [Dnsimple::RequestError]
+      def create_contact(account_id, attributes, options = {})
         Extra.validate_mandatory_attributes(attributes, [:first_name, :last_name, :address1, :city, :state_province, :postal_code, :country, :phone, :email_address])
-        options  = options.merge(contact: attributes)
-        response = client.post(Client.versioned("/contacts"), options)
+        response = client.post(Client.versioned("/%s/contacts" % [account_id]), attributes, options)
 
-        Struct::Contact.new(response["contact"])
+        Dnsimple::Response.new(response, Struct::Contact.new(response["data"]))
       end
       alias :create :create_contact
 
       # Gets a contact from the account.
       #
-      # @see http://developer.dnsimple.com/v1/contacts/#get
+      # @see https://developer.dnsimple.com/v2/contacts/#get
       #
-      # @param  [Fixnum] contact The contact id.
-      # @return [Struct::Contact]
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] contact_id the contact ID
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::Contact>]
       #
-      # @raise  [NotFoundError]
-      # @raise  [RequestError] When the request fails.
-      def contact(contact, options = {})
-        response = client.get(Client.versioned("/contacts/#{contact}"), options)
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def contact(account_id, contact_id, options = {})
+        response = client.get(Client.versioned("/%s/contacts/%s" % [account_id, contact_id]), options)
 
-        Struct::Contact.new(response["contact"])
+        Dnsimple::Response.new(response, Struct::Contact.new(response["data"]))
       end
 
       # Updates a contact in the account.
       #
-      # @see http://developer.dnsimple.com/v1/contacts/#update
+      # @see https://developer.dnsimple.com/v2/contacts/#update
       #
-      # @param  [Fixnum] contact The contact id.
+      # @param  [Fixnum] account_id the account ID
+      # @param  [#to_s] contact_id the contact ID
       # @param  [Hash] attributes
-      # @return [Struct::Contact]
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::Contact>]
       #
-      # @raise  [NotFoundError]
-      # @raise  [RequestError] When the request fails.
-      def update_contact(contact, attributes = {}, options = {})
-        options  = options.merge(contact: attributes)
-        response = client.put(Client.versioned("/contacts/#{contact}"), options)
+      # @raise  [Dnsimple::RequestError]
+      def update_contact(account_id, contact_id, attributes, options = {})
+        response = client.patch(Client.versioned("/%s/contacts/%s" % [account_id, contact_id]), attributes, options)
 
-        Struct::Contact.new(response["contact"])
+        Dnsimple::Response.new(response, Struct::Contact.new(response["data"]))
       end
       alias :update :update_contact
 
@@ -71,15 +104,19 @@ module Dnsimple
       #
       # WARNING: this cannot be undone.
       #
-      # @see http://developer.dnsimple.com/v1/contacts/#delete
+      # @see https://developer.dnsimple.com/v2/contacts/#delete
       #
-      # @param  [Fixnum] contact The contact id.
-      # @return [void]
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] contact_id the contact ID
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
       #
-      # @raise  [NotFoundError]
-      # @raise  [RequestError] When the request fails.
-      def delete_contact(contact, options = {})
-        client.delete(Client.versioned("contacts/#{contact}"), options)
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def delete_contact(account_id, contact_id, options = {})
+        response = client.delete(Client.versioned("/%s/contacts/%s" % [account_id, contact_id]), nil, options)
+
+        Dnsimple::Response.new(response, nil)
       end
       alias :delete :delete_contact
 

data/lib/dnsimple/client/domains.rb

@@ -4,68 +4,122 @@ module Dnsimple
 
       # Lists the domains in the account.
       #
-      # @see http://developer.dnsimple.com/v1/domains/#list
+      # @see https://developer.dnsimple.com/v2/domains/#list
+      # @see #all_domains
       #
+      # @example List domains in the first page
+      #   client.domains.list(1010)
+      #
+      # @example List domains, provide a specific page
+      #   client.domains.list(1010, query: { page: 2 })
+      #
+      # @param  [Fixnum] account_id the account ID
       # @param  [Hash] options the filtering and sorting option
-      # @return [Array<Struct::Domain>]
+      # @return [Dnsimple::PaginatedResponse<Dnsimple::Struct::Domain>]
       #
-      # @raise  [RequestError] When the request fails.
-      def domains(options = {})
-        response = client.get(Client.versioned("/domains"), options)
+      # @raise  [Dnsimple::RequestError]
+      def domains(account_id, options = {})
+        response = client.get(Client.versioned("/%s/domains" % [account_id]), options)
 
-        response.map { |r| Struct::Domain.new(r["domain"]) }
+        Dnsimple::PaginatedResponse.new(response, response["data"].map { |r| Struct::Domain.new(r) })
       end
       alias :list :domains
       alias :list_domains :domains
 
+      # Lists ALL the domains in the account.
+      #
+      # This method is similar to {#domains}, but instead of returning the results of a specific page
+      # it iterates all the pages and returns the entire collection.
+      #
+      # Please use this method carefully, as fetching the entire collection will increase the number of requests
+      # you send to the API server and you may eventually risk to hit the throttle limit.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/#list
+      # @see #domains
+      #
+      # @param  [Fixnum] account_id the account ID
+      # @param  [Hash] options the filtering and sorting option
+      # @return [Dnsimple::CollectionResponse<Dnsimple::Struct::Domain>]
+      #
+      # @raise  [Dnsimple::RequestError]
+      def all_domains(account_id, options = {})
+        paginate(:domains, account_id, options)
+      end
+      alias :all :all_domains
+
       # Creates a domain in the account.
       #
-      # @see http://developer.dnsimple.com/v1/domains/#create
+      # @see https://developer.dnsimple.com/v2/domains/#create
       #
+      # @param  [Fixnum] account_id the account ID
       # @param  [Hash] attributes
-      # @return [Struct::Domain]
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::Domain>]
       #
-      # @raise  [RequestError] When the request fails.
-      def create_domain(attributes = {}, options = {})
+      # @raise  [Dnsimple::RequestError]
+      def create_domain(account_id, attributes, options = {})
         Extra.validate_mandatory_attributes(attributes, [:name])
-        options  = options.merge({ domain: attributes })
-        response = client.post(Client.versioned("/domains"), options)
+        options  = options.merge(attributes)
+        response = client.post(Client.versioned("/%s/domains" % [account_id]), attributes, options)
 
-        Struct::Domain.new(response["domain"])
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
       end
       alias :create :create_domain
 
       # Gets a domain from the account.
       #
-      # @see http://developer.dnsimple.com/v1/domains/#get
+      # @see https://developer.dnsimple.com/v2/domains/#get
       #
-      # @param  [#to_s] domain The domain id or domain name.
-      # @return [Struct::Domain]
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<Dnsimple::Struct::Domain>]
       #
-      # @raise  [NotFoundError]
-      # @raise  [RequestError] When the request fails.
-      def domain(domain, options = {})
-        response = client.get(Client.versioned("/domains/#{domain}"), options)
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def domain(account_id, domain_id, options = {})
+        response = client.get(Client.versioned("/%s/domains/%s" % [account_id, domain_id]), options)
 
-        Struct::Domain.new(response["domain"])
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
       end
 
       # Deletes a domain from the account.
       #
       # WARNING: this cannot be undone.
       #
-      # @see http://developer.dnsimple.com/v1/domains/#delete
+      # @see https://developer.dnsimple.com/v2/domains/#delete
       #
-      # @param  [#to_s] domain The domain id or domain name.
-      # @return [void]
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
       #
-      # @raise  [NotFoundError]
-      # @raise  [RequestError] When the request fails.
-      def delete_domain(domain, options = {})
-        client.delete(Client.versioned("/domains/#{domain}"), options)
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def delete_domain(account_id, domain_id, options = {})
+        response = client.delete(Client.versioned("/%s/domains/%s" % [account_id, domain_id]), nil, options)
+
+        Dnsimple::Response.new(response, nil)
       end
       alias :delete :delete_domain
 
+      # Resets the domain token.
+      #
+      # @see https://developer.dnsimple.com/v2/domains/#reset-token
+      #
+      # @param  [Fixnum, Dnsimple::Client::WILDCARD_ACCOUNT] account_id the account ID or wildcard
+      # @param  [#to_s] domain_id The domain ID or domain name
+      # @param  [Hash] options
+      # @return [Dnsimple::Response<nil>]
+      #
+      # @raise  [Dnsimple::NotFoundError]
+      # @raise  [Dnsimple::RequestError]
+      def reset_domain_token(account_id, domain_id, options = {})
+        response = client.post(Client.versioned("/%s/domains/%s/token" % [account_id, domain_id]), nil, options)
+
+        Dnsimple::Response.new(response, Struct::Domain.new(response["data"]))
+      end
+
     end
   end
 end