dnsimple 2.0.0.alpha2 → 2.0.0.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e16688144a4991e78dc2f86e78dbc558c011aa4
-  data.tar.gz: f7dc21999ebef6b8bfee73a6a9d0afefad8ca89e
+  metadata.gz: 59bd049e932b2627935ec1c20b461c044a469db7
+  data.tar.gz: 339e7ddd3c26886983121c50b9f0600d4e91d458
 SHA512:
-  metadata.gz: 461f978e357d7a1b6895253d8c1488f7d8b720fd00b1ef80008b83071ca6d4dc8b5aafcefe927b90aacc708deda5de9fbed6f491de67ef56d0bad4d44adc087c
-  data.tar.gz: aef1ebfd28622173d53fc183a5834f5b42390fc3c7d4aff75686456b9d578fe5059430aab72436c55df836284bde6bde638538d524572bde220fe14e706531ee
+  metadata.gz: 18d6712c612148898493bacc510a5686233407b670125cc8da40a5152b7b19dca74217b316ffd7f81a6e62ebf678f502213dcaf3887a999a96ee0fafec171337
+  data.tar.gz: b8342199df7bee17d7483f09b9b32a22e076e694a69a12c43e06718f3392f6197bd4f06f838f67382cc911b776daa250ccc98152d7f6ab9f37ee2fcdd7e81327

data/CHANGELOG.markdown

@@ -2,19 +2,23 @@
 
 #### 2.0.0.alpha
 
+- NEW: Add support changing name servers (GH-52). Thanks @rosscooperman
+
 - CHANGED: Drop 1.8.7 support.
 
 - CHANGED: This package no longer provides a CLI. The CLI has been extracted to [aetrion/dnsimple-ruby-cli](https://github.com/aetrion/dnsimple-ruby-cli)
 
-- CHANGED: Renamed the Gem from "dnsimple-ruby" to "dnsimple". (GH-23)
+- CHANGED: Renamed the Gem from "dnsimple-ruby" to "dnsimple" (GH-23).
 
 - CHANGED: Renamed the namespace from DNSimple to Dnsimple.
 
+- CHANGED: Redesigned client API.
+
 - REMOVED: The library no longer provides built-in support for loading the credentials from a config file.
 
 #### Release 1.7.1
 
-- FIXED: Updated Certificate to match the serialized attributes (GH-53)
+- FIXED: Updated Certificate to match the serialized attributes (GH-53).
 
 #### Release 1.7.0
 

data/README.markdown

@@ -11,48 +11,50 @@ We provide a full API and an easy-to-use web interface so you can get your domai
 
 ## Installation
 
-    $ gem install dnsimple
+```
+$ gem install dnsimple
+```
+
 
+## Getting Started
 
-## DNSimple Client
+This library is a Ruby client you can use to interact with the [DNSimple API](http://developer.dnsimple.com/). 
 
-This library provides a Ruby DNSimple client you can use to interact with the [DNSimple API](http://developer.dnsimple.com/). Here's a short example.
+Here's a short example.
 
 ```ruby
 require 'dnsimple'
 
-DNSimple::Client.username   = 'YOUR_USERNAME'
-DNSimple::Client.password   = 'YOUR_PASSWORD'
+client = Dnsimple::Client.new(username: 'YOUR_USERNAME', api_token: 'YOUR_TOKEN')
 
-user = DNSimple::User.me
-puts "#{user.domain_count} domains"
+# Fetch your user details
+user = client.users.user
+puts "My email is #{user.email}"
 
-puts "Domains..."
-DNSimple::Domain.all.each do |domain|
-  puts "  #{domain.name}"
+# Get a list of your domains
+domains = client.domains.list
+domains.each do |domain|
+  puts "Domain: %s (id: %d)" % [domain.name, domain.id]
 end
 
-domain = DNSimple::Domain.find("example.com")
-domain.apply("template") # applies a standard or custom template to the domain
-
-domain = DNSimple::Domain.create("newdomain.com")
-puts "Added #{domain.name}"
-domain.delete # removes from DNSimple
+# Create a domain
+domain = client.domains.create("example.com")
+puts "Domain: %s (id: %d)" % [domain.name, domain.id]
 ```
 
-For the full API documentation visit http://rubydoc.info/gems/dnsimple
+For the full library documentation visit http://rubydoc.info/gems/dnsimple
+
 
-### Authentication
+## Authentication
 
 This client supports both the HTTP Basic and API Token authentication mechanism.
 
 #### HTTP Basic
 
 ```ruby
-DNSimple::Client.username = 'YOUR_USERNAME'
-DNSimple::Client.password = 'YOUR_PASSWORD'
-
-user = DNSimple::User.me
+client = Dnsimple::Client.new(username: 'YOUR_USERNAME', password: 'YOUR_PASSWORD')
+client.users.user
+# => Dnsimple::Struct::User
 ```
 
 #### HTTP Basic with two-factor authentication enabled
@@ -61,20 +63,20 @@ See the [2FA API documentation](http://developer.dnsimple.com/authentication/#tw
 
 ```ruby
 # Request the 2FA exchange token
-DNSimple::Client.username = 'YOUR_USERNAME'
-DNSimple::Client.password = 'YOUR_PASSWORD'
-token = DNSimple::User.two_factor_exchange_token('otp-token')
+client = Dnsimple::Client.new(username: 'YOUR_USERNAME', password: 'YOUR_PASSWORD')
+token  = client.users.exchange_token('otp-token')
 
 # Authenticate with the exchange token
-DNSimple::Client.exchange_token = token
-user = DNSimple::User.me
+client.exchange_token = token
+client.users.user
+# => Dnsimple::Struct::User
 ```
 
 #### API Token
 
 ```ruby
-DNSimple::Client.username  = 'YOUR_USERNAME'
-DNSimple::Client.api_token = 'API_TOKEN'
+client = Dnsimple::Client.new(username: 'YOUR_USERNAME', api_token: 'YOUR_TOKEN')
 
-user = DNSimple::User.me
+client.users.user
+# => Dnsimple::Struct::User
 ```

data/dnsimple.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.email       = ['anthony.eden@dnsimple.com', 'simone.carletti@dnsimple.com']
   s.homepage    = 'http://github.com/aetrion/dnsimple-ruby'
   s.summary     = 'A Ruby client for the DNSimple API'
-  s.description = 'A Ruby client for the DNSimple API that also includes a command-line client.'
+  s.description = 'A Ruby client for the DNSimple API.'
 
   s.required_ruby_version = ">= 1.9.3"
 
@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
   s.add_dependency  'httparty'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'mocha'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'webmock'

data/lib/dnsimple.rb

@@ -2,8 +2,6 @@ require 'httparty'
 
 module Dnsimple
 
-  BLANK_REGEX = /\S+/
-
   # Echoes a deprecation warning message.
   #
   # @param  [String] message The message to display.
@@ -18,16 +16,7 @@ module Dnsimple
 
 end
 
-require 'dnsimple/base'
+require 'dnsimple/version'
+require 'dnsimple/default'
 require 'dnsimple/client'
 require 'dnsimple/error'
-require 'dnsimple/user'
-require 'dnsimple/contact'
-require 'dnsimple/domain'
-require 'dnsimple/record'
-require 'dnsimple/template'
-require 'dnsimple/template_record'
-require 'dnsimple/transfer_order'
-require 'dnsimple/extended_attribute'
-require 'dnsimple/service'
-require 'dnsimple/certificate'

data/lib/dnsimple/client.rb

@@ -1,96 +1,207 @@
-require 'dnsimple/version'
-require 'yaml'
+require 'dnsimple/compatibility'
+require 'dnsimple/extra'
+require 'dnsimple/struct'
+require 'dnsimple/client/client_service'
+require 'dnsimple/client/certificates_service'
+require 'dnsimple/client/contacts_service'
+require 'dnsimple/client/domains_service'
+require 'dnsimple/client/name_servers_service'
+require 'dnsimple/client/registrars_service'
+require 'dnsimple/client/services_service'
+require 'dnsimple/client/templates_service'
+require 'dnsimple/client/users_service'
 
 module Dnsimple
+
+  # Client for the DNSimple API
+  #
+  # @see http://developer.dnsimple.com
   class Client
+    include Dnsimple::Compatibility
 
-    DEFAULT_BASE_URI = "https://api.dnsimple.com/"
     HEADER_2FA_STRICT = "X-DNSimple-2FA-Strict"
     HEADER_API_TOKEN = "X-DNSimple-Token"
     HEADER_DOMAIN_API_TOKEN = "X-DNSimple-Domain-Token"
     HEADER_OTP_TOKEN = "X-DNSimple-OTP"
     HEADER_EXCHANGE_TOKEN = "X-DNSimple-OTP-Token"
 
-    class << self
-      # @return [Boolean] if the debug mode is enabled.
-      #   Defaults to false.
-      attr_accessor :debug
 
-      attr_accessor :username, :password, :exchange_token, :api_token, :domain_api_token
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for API requests. (default: https://api.dnsimple.com/)
+    # @!attribute username
+    #   @return [String] DNSimple username for Basic Authentication
+    # @!attribute password
+    #   @see http://developer.dnsimple.com/authentication/
+    #   @return [String] DNSimple password for Basic Authentication
+    # @!attribute exchange_token
+    #   @see http://developer.dnsimple.com/authentication/
+    #   @return [String] Exchange Token for Basic Authentication with 2FA
+    # @!attribute api_token
+    #   @see http://developer.dnsimple.com/authentication/
+    #   @return [String] API access token for authentication
+    # @!attribute domain_api_token
+    #   @see http://developer.dnsimple.com/authentication/
+    #   @return [String] Domain API access token for authentication
+    # @!attribute user_agent
+    #   @return [String] Configure User-Agent header for requests.
+    # @!attribute proxy
+    #   @return [String,nil] Configure address:port values for proxy server
+
+    attr_accessor :api_endpoint, :username, :password, :exchange_token, :api_token, :domain_api_token,
+                  :user_agent, :proxy
+
+
+    def initialize(options = {})
+      defaults = Dnsimple::Default.options
+
+      Dnsimple::Default.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || defaults[key])
+      end
+
+      @services = {}
+    end
+
+
+    # Make a HTTP GET request.
+    #
+    # @param  [String] url The path, relative to {#api_endpoint}
+    # @param  [Hash] options Query and header params for request
+    # @return [HTTParty::Response]
+    def get(path, options = {})
+      request :get, path, options
     end
 
-    # Gets the qualified API base uri.
+    # Make a HTTP POST request.
     #
-    # @return [String] The qualified API base uri.
-    def self.base_uri
-      @base_uri ||= DEFAULT_BASE_URI.chomp("/")
+    # @param  [String] url The path, relative to {#api_endpoint}
+    # @param  [Hash] options Body and header params for request
+    # @return [HTTParty::Response]
+    def post(path, options = {})
+      request :post, path, options
     end
 
-    # Sets the qualified API base uri.
+    # Make a HTTP PUT request.
     #
-    # @param [String] value The qualified API base uri.
-    def self.base_uri=(value)
-      @base_uri = value.to_s.chomp("/")
+    # @param  [String] url The path, relative to {#api_endpoint}
+    # @param  [Hash] options Body and header params for request
+    # @return [HTTParty::Response]
+    def put(path, options = {})
+      request :put, path, options
     end
 
-    def self.http_proxy
-      @http_proxy
+    # Make a HTTP DELETE request.
+    #
+    # @param  [String] url The path, relative to {#api_endpoint}
+    # @param  [Hash] options Query and header params for request
+    # @return [HTTParty::Response]
+    def delete(path, options = {})
+      request :delete, path, options
     end
 
-    def self.base_options
-      options = {
-        :format => :json,
-        :headers => { 'Accept' => 'application/json', 'User-Agent' => "dnsimple-ruby/#{VERSION}" },
-      }
 
-      if http_proxy
-        options.merge!(
-          :http_proxyaddr => http_proxy[:addr],
-          :http_proxyport => http_proxy[:port]
-        )
+    # Make a HTTP request.
+    #
+    # @param  [String] method The HTTP method
+    # @param  [String] url The path, relative to {#api_endpoint}
+    # @param  [Hash] options Query and header params for request
+    # @return [HTTParty::Response]
+    def request(method, path, data, options = {})
+      if data.is_a?(Hash)
+        options[:query]   = data.delete(:query)   if data.key?(:query)
+        options[:headers] = data.delete(:headers) if data.key?(:headers)
+      end
+      if !data.empty?
+        options[:body] = data
       end
 
-      if exchange_token
-        options[:basic_auth] = { :username => exchange_token, :password => "x-2fa-basic" }
-      elsif password
-        options[:basic_auth] = { :username => username, :password => password }
-      elsif domain_api_token
-        options[:headers][HEADER_DOMAIN_API_TOKEN] = domain_api_token
-      elsif api_token
-        options[:headers][HEADER_API_TOKEN] = "#{username}:#{api_token}"
+      response = HTTParty.send(method, api_endpoint + path, Extra.deep_merge!(base_options, options))
+
+      case response.code
+      when 200..299
+        response
+      when 401
+        raise (response.headers[HEADER_OTP_TOKEN] == "required" ? TwoFactorAuthenticationRequired : AuthenticationFailed), response["message"]
+      when 404
+        raise RecordNotFound.new(response)
       else
-        raise Error, 'A password or API token is required for all API requests.'
+        raise RequestError.new(response)
       end
+    end
 
-      options
+
+    # @return [Dnsimple::Client::CertificatesService] The certificate-related API proxy.
+    def certificates
+      @services[:certificates] ||= Client::CertificatesService.new(self)
     end
 
-    def self.get(path, options = {})
-      request :get, path, options
+    # @return [Dnsimple::Client::ContactsService] The contact-related API proxy.
+    def contacts
+      @services[:contacts] ||= Client::ContactsService.new(self)
     end
 
-    def self.post(path, options = {})
-      request :post, path, options
+    # @return [Dnsimple::Client::DomainsService] The domain-related API proxy.
+    def domains
+      @services[:domains] ||= Client::DomainsService.new(self)
     end
 
-    def self.put(path, options = {})
-      request :put, path, options
+    # @return [Dnsimple::Client::NameServersService] The name server-related API proxy.
+    def name_servers
+      @services[:name_servers] ||= Client::NameServersService.new(self)
     end
 
-    def self.delete(path, options = {})
-      request :delete, path, options
+    # @return [Dnsimple::Client::RegistrarsService] The registrar-related API proxy.
+    def registrars
+      @services[:registrars] ||= Client::RegistrarsService.new(self)
+    end
+
+    # @return [Dnsimple::Client::ServicesService] The service-related API proxy.
+    def services
+      @services[:services] ||= Client::ServicesService.new(self)
+    end
+
+    # @return [Dnsimple::Client::TemplatesService] The template-related API proxy.
+    def templates
+      @services[:templates] ||= Client::TemplatesService.new(self)
     end
 
-    def self.request(method, path, options)
-      response = HTTParty.send(method, "#{base_uri}#{path}", base_options.merge(options))
+    # @return [Dnsimple::Client::UsersService] The user-related API proxy.
+    def users
+      @services[:users] ||= Client::UsersService.new(self)
+    end
+
+
+    # @return [String] Base URL for API requests.
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
 
-      if response.code == 401 && response.headers[HEADER_OTP_TOKEN] == "required"
-        raise TwoFactorAuthenticationRequired, response["message"]
-      elsif response.code == 401
-        raise AuthenticationFailed, response["message"]
+
+    private
+
+    def base_options
+      options = {
+          format:   :json,
+          headers:  { 'Accept' => 'application/json', 'User-Agent' => user_agent },
+      }
+
+      if proxy
+        address, port = proxy.split(":")
+        options.merge!(http_proxyaddr: address, http_proxyport: port)
       end
 
-      response
+      if exchange_token
+        options[:basic_auth] = { username: exchange_token, password: "x-2fa-basic" }
+      elsif password
+        options[:basic_auth] = { username: username, password: password }
+      elsif domain_api_token
+        options[:headers][HEADER_DOMAIN_API_TOKEN] = domain_api_token
+      elsif api_token
+        options[:headers][HEADER_API_TOKEN] = "#{username}:#{api_token}"
+      else
+        raise Error, 'A password or API token is required for all API requests.'
+      end
+
+      options
     end
 
   end

data/lib/dnsimple/client/certificates_service.rb

@@ -0,0 +1,98 @@
+module Dnsimple
+  class Client
+    class CertificatesService < ClientService
+
+      # Lists the certificates for a domain.
+      #
+      # @see http://developer.dnsimple.com/domains/certificates/#list
+      #
+      # @param  [#to_s] domain The domain id or domain name.
+      # @param  [Hash] options
+      #
+      # @return [Array<Struct::Certificate>]
+      # @raise  [RecordNotFound]
+      # @raise  [RequestError] When the request fails.
+      def list(domain, options = {})
+        response = client.get("v1/domains/#{domain}/certificates", options)
+
+        response.map { |r| Struct::Certificate.new(r["certificate"]) }
+      end
+
+      # Gets a certificate for a domain.
+      #
+      # @see http://developer.dnsimple.com/domains/certificates/#get
+      #
+      # @param  [#to_s] domain The domain id or domain name.
+      # @param  [Fixnum] certificate_id The certificate ID.
+      #
+      # @return [Struct::Certificate]
+      # @raise  [RecordNotFound]
+      # @raise  [RequestError] When the request fails.
+      def find(domain, certificate_id)
+        response = client.get("v1/domains/#{domain}/certificates/#{certificate_id}")
+
+        Struct::Certificate.new(response["certificate"])
+      end
+
+      # Purchases a certificate under the given domain with the given name.
+      #
+      # The name will be appended to the domain name, and thus should only be the subdomain part.
+      #
+      # Invoking this method DNSimple will immediately charge
+      # your credit card on file at DNSimple for the full certificate price.
+      #
+      # For wildcard certificates an asterisk must appear in the name.
+      #
+      # @example Purchase a single-hostname certificate
+      #   Dnsimple::Certificate.purchase(domain, 'www', contact)
+      #
+      # @example Purchase a wildcard certificate
+      #   Dnsimple::Certificate.purchase(domain, '*', contact)
+      #
+      # @param  [#to_s] domain The domain id or domain name.
+      # @param  [String] name The certificate name.
+      # @param  [Fixnum] contact_id The ID of the contact associated to the certificate.
+      #
+      # @return [Struct::Certificate]
+      # @raise  [RecordNotFound]
+      # @raise  [RequestError] When the request fails.
+      def purchase(domain, name, contact_id, options = {})
+        options  = Extra.deep_merge(options, { certificate: { name: name, contact_id: contact_id }})
+        response = client.post("v1/domains/#{domain}/certificates", options)
+
+        Struct::Certificate.new(response["certificate"])
+      end
+
+      # Configures a certificate.
+      #
+      # @param  [#to_s] domain The domain id or domain name.
+      # @param  [Fixnum] certificate_id The certificate ID.
+      #
+      # @return [Struct::Certificate]
+      # @raise  [RecordNotFound]
+      # @raise  [RequestError] When the request fails.
+      def configure(domain, certificate_id)
+        response = client.put("v1/domains/#{domain}/certificates/#{certificate_id}/configure")
+
+        Struct::Certificate.new(response["certificate"])
+      end
+
+      # Submits a certificate for approval.
+      #
+      # @param  [#to_s] domain The domain id or domain name.
+      # @param  [Fixnum] certificate_id The certificate ID.
+      # @param  [Fixnum] email The approver email.
+      #
+      # @return [Struct::Certificate]
+      # @raise  [RecordNotFound]
+      # @raise  [RequestError] When the request fails.
+      def submit(domain, certificate_id, email)
+        options = { certificate: { approver_email: email }}
+        response = client.put("v1/domains/#{domain}/certificates/#{certificate_id}/submit", options)
+
+        Struct::Certificate.new(response["certificate"])
+      end
+
+    end
+  end
+end