gandirb 1.1.1 → 2.0.0

data/lib/gandi/domain/mailbox.rb

@@ -0,0 +1,72 @@
+module Gandi
+  class Domain
+    class Mailbox
+      include Gandi::GandiObjectMethods
+      
+      attr_reader :domain, :login
+      
+      def initialize(domain, login, attributes = nil)
+        @domain = domain
+        @login = login
+        @attributes = attributes || info
+      end
+      
+      #Delete a mailbox.
+      #Note: the mailbox is deleted instantly.
+      def delete
+        self.class.call('domain.mailbox.delete', @domain.fqdn, @login)
+      end
+      
+      #Get mailbox information for a given login created for a given domain.
+      def info
+        self.class.call('domain.mailbox.info', @domain.fqdn, @login)
+      end
+      
+      #Purge a mailbox.
+      #Create an operation that will delete this mailbox contents.
+      #Return a Gandi::Operation object.
+      def purge
+        operation_hash = self.class.call('domain.mailbox.purge', @domain.fqdn, @login)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+      
+      #Update a mailbox.
+      #Returns a Gandi::Operation object.
+      def update(params)
+        operation_hash = self.class.call('domain.mailbox.update', @domain.fqdn, @login, params)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+      
+      class << self
+        #Create a mailbox.
+        #Return a Mailbox object.
+        def create(domain, login, params)
+          mailbox = call('domain.mailbox.create', domain.fqdn, login, params)
+          self.new(domain, login, mailbox)
+        end
+        
+        #Count mailboxes for a given domain.
+        #TODO: accept a fqdn string.
+        def count(domain, opts = {})
+          call('domain.mailbox.count', domain.fqdn, opts)
+        end
+        
+        #List mailboxes for a given domain.
+        #Return an array of Mailbox objects or an array of hashes.
+        #Note that domain.mailbox.info will be called for each mailbox unless map_mailboxes is set to false (as the info hash returned by domain.mailbox.list does not contain the mailboxes attributes).
+        #This may result in a lot of API calls if you have many registered mailboxes for your domain, so using opts to restrict results is advised (or use a raw API call).
+        #TODO: accept a fqdn string.
+        def list(domain, opts = {}, map_mailboxes = true)
+          mailboxes = call('domain.mailbox.list', domain.fqdn, opts)
+          
+          if map_mailboxes
+            mailboxes.map! do |mailbox|
+              self.new(domain, mailbox['login'])
+            end
+          end
+          return mailboxes
+        end
+      end
+    end
+  end
+end

data/lib/gandi/domain/nameservers.rb

@@ -0,0 +1,17 @@
+module Gandi
+  class Domain
+    module Nameservers
+      #Returns the domains nameservers.
+      def nameservers
+        @attributes['nameservers']
+      end
+      
+      #Define the nameservers for a given domain. Uses the API call domain.nameservers.set
+      #Returns a Gandi::Operation object.
+      def nameservers=(nameservers)
+        operation_hash = self.class.call('domain.nameservers.set', @fqdn, nameservers)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+    end
+  end
+end

data/lib/gandi/domain/status.rb

@@ -0,0 +1,19 @@
+module Gandi
+  class Domain
+    module Status
+      #Lock a domain, set the ‘clientTransferProhibited’ status flag.
+      #Returns a Gandi::Operation object.
+      def lock
+        operation_hash = self.class.call('domain.status.lock', @fqdn)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+      
+      #Unlock a domain, unset the ‘clientTransferProhibited’ status flag.
+      #Returns a Gandi::Operation object.
+      def unlock
+        operation_hash = self.class.call('domain.status.unlock', @fqdn)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+    end
+  end
+end

data/lib/gandi/domain/tld.rb

@@ -0,0 +1,17 @@
+module Gandi
+  class Domain
+    class Tld
+      extend Gandi::Connector
+      
+      #List all tld available in API.
+      def self.list
+        call('domain.tld.list')
+      end
+      
+      #List all tld by region, available in API.
+      def self.region
+        call('domain.tld.region')
+      end
+    end
+  end
+end

data/lib/gandi/domain/transferin.rb

@@ -0,0 +1,13 @@
+module Gandi
+  class Domain
+    module Transferin
+      #Transfer a domain. Uses the API call domain.transferin.proceed
+      #Returns a Gandi::Operation object.
+      #NOTE: this may be untestable in OT&E
+      def transferin(fqdn, params)
+        operation_hash = call('domain.transferin.proceed', fqdn, params)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
+    end
+  end
+end

data/lib/gandi/domain.rb

@@ -1,133 +1,66 @@
-require 'gandi/domain_modules/name_servers'
-require 'gandi/domain_modules/host'
-require 'gandi/domain_modules/redirection'
-require 'gandi/domain_modules/contact'
-require 'gandi/domain_modules/operations'
-require 'gandi/domain_modules/mail'
+# encoding: utf-8
 
-module Gandi
-  class Domain < Gandi::Base
-    #Returns an array of domains for which the logged user is the reseller or a contact (owner, administrative, billing or technical).
-    #TODO: memoize results 
-    def domain_list
-      call('domain_list')
-    end
-    
-    #Check a domain availability.
-    #This implementation does not respect the original API specifications and allow for a single domain to be checked.
-    #In this case the domain can be provided as a string and a boolean will be returned.
-    def domain_available(domains)
-      available_domains = call('domain_available', [domains].flatten)
-      return (domains.is_a?(String)) ? available_domains.values.first : available_domains
-    end
-    
-    #Add a lock status (cf. domain_info) to avoid any fraudulent transfer.
-    #Return the operation attributed ID
-    def domain_lock(domain)
-      call('domain_lock', domain)
-    end
-    
-    #Remove a lock status (cf. domain_info) to transfer the domain to another registrar.
-    #Return the operation attributed ID
-    def domain_unlock(domain)
-      call('domain_unlock', domain)
-    end
-    
-    #Retrieve the informations linked to this domain (contacts, nameservers, redirections, weblogs...). 
-    #This method only works on domains handled by Gandi.
-    #Return a hash with string keys containing domain informations (see API documentation)
-    #TODO: convert XMLRPC datetimes ?
-    def domain_info(domain)
-      call('domain_info', domain)
-    end
-    
-    #Renew a domain for a number of years.
-    #The total number of years cannot exceed 10.
-    #Return the operation attributed ID
-    def domain_renew(domain, period)
-      raise ArgumentError.new("The total number of years cannot exceed 10") if period > 10
-      call('domain_renew', domain, period)
-    end
-    
-    #Register a domain with Gandi and associate it to a list of contacts.
-    #Return the operation attributed ID
-    def domain_create(domain, period, owner_handle, admin_handle, tech_handle, billing_handle, nameservers, lang = nil)
-      args = [domain, period, owner_handle, admin_handle, tech_handle, billing_handle, nameservers, lang]
-      args.pop if lang.nil?
-      call('domain_create', *args)
-    end
-    
-    #Get a domain out of its redemption period. See glossary, Restore.
-    #This function is available for domains in .COM, .NET, .BE or .EU.
-    #Return the operation attributed ID
-    #TODO: Check for domain correctness
-    def domain_restore(domain)
-      call('domain_restore', domain)
-    end
-    
-    #Delete a domain.
-    #Return the operation attributed ID
-    #This method is not available yet and will be present in v1.10 of the API
-    def domain_del(domain)
-      not_supported
-    end
-    
-    #Check if a domain can be transferred from another registrar. See glossary, Transfer.
-    def domain_transfer_in_available(domain)
-      call('domain_transfer_in_available', domain)
-    end
-    
-    alias_method :domain_transfer_in_available?, :domain_transfer_in_available
-    
-    #Transfer (see glossary, Transfer) a domain from another registrar to Gandi, or from a Gandi account to a Gandi reseller. 
-    #If the domain is already at Gandi (internal transfer), owner_handle, admin_handle, tech_handle and billing_handle are maintained.
-    #Return the operation attributed ID
-    #TODO: check for auth_code if TLD is .fr
-    def domain_transfer_in(domain, owner_handle, admin_handle, tech_handle, billing_handle, nameservers, auth_code = nil)
-      args = [domain, owner_handle, admin_handle, tech_handle, billing_handle, nameservers, auth_code]
-      args.pop if auth_code.nil?
-      call('domain_transfer_in', *args)
-    end
-    
-    #Accept or deny a transfer of a domain from Gandi to another registrar. See glossary, Transfer.
-    #This method is not available yet and will be present in v1.10 of the API
-    def domain_transfer_out(opid, allow)
-      not_supported
-    end
-    
-    #Start the trade of a domain from another registrar to Gandi.
-    #Return the operation attributed ID
-    #This method is not available yet and will be present in v1.10 of the API
-    def domain_trade(domain, owner_handle, admin_handle, tech_handle, billing_handle, afnic_titularkey = nil)
-      not_supported
-    end
-    
-    #Change the owner of a domain registered with Gandi and, optionally, the admin, tech and billing contacts. See glossary, Change of Ownership.
-    #Return the operation attributed ID
-    #This method is not available yet and will be present in v1.10 of the API
-    def domain_change_owner(domain, new_owner, new_admin = nil, new_tech = nil, new_billing = nil)
-      not_supported
-    end
-    
-    #Change a given contact of a domain registered with Gandi.
-    #Return the operation attributed ID
-    def domain_change_contact(domain, type, new_contact)
-      call('domain_change_contact', domain, type, new_contact)
-    end
-    
-    #Misc methods
+require 'gandi/domain/tld'
+require 'gandi/domain/contacts'
+require 'gandi/domain/status'
+require 'gandi/domain/transferin'
+require 'gandi/domain/nameservers'
+require 'gandi/domain/host'
+require 'gandi/domain/mailbox'
+require 'gandi/domain/forward'
 
-    #Return an array of active TLDs handled by the application.
-    #TODO: memoization
-    def tld_list
-      call('tld_list')
+module Gandi
+  class Domain
+    include Gandi::GandiObjectMethods
+    include Gandi::Domain::Contacts
+    include Gandi::Domain::Status
+    extend Gandi::Domain::Transferin
+    include Gandi::Domain::Nameservers
+    
+    attr_reader :fqdn
+    
+    def initialize(fqdn)
+      @fqdn = fqdn
+      @attributes = info
+    end
+    
+    #get domain information.
+    def info
+      self.class.call('domain.info', @fqdn)
+    end
+    
+    #Renew a domain.
+    def renew(params)
+      operation_hash = self.class.call('domain.renew', @fqdn, params)
+      Gandi::Operation.new(operation_hash['id'], operation_hash)
+    end
+    
+    class << self
+      #Check the availability of some domain names.
+      def available(fqdns)
+        call('domain.available', fqdns)
+      end
+      
+      #Count domains visible by this account.
+      def count(filters = {})
+        call('domain.count', filters)
+      end
+      
+      #List operations done by this account.
+      #Note that domain.info will be called for each domain (as the info hash returned by domain.list is missing some informations).
+      #This may result in a lot of API calls if you have many registered domains for your contact, so using opts to restrict results is advised (or use a raw API call).
+      def list(opts = {})
+        call('domain.list', opts).map do |domain|
+          self.new(domain['fqdn'])
+        end
+      end
+      
+      #Create a domain with the given information.
+      #Returns a Gandi::Domain object.
+      def create(fqdn, params)
+        operation_hash = call('domain.create', fqdn, params)
+        Gandi::Operation.new(operation_hash['id'], operation_hash)
+      end
     end
-    
-    include Gandi::DomainModules::NameServers
-    include Gandi::DomainModules::Host
-    include Gandi::DomainModules::Redirection
-    include Gandi::DomainModules::Contact
-    include Gandi::DomainModules::Operations
-    include Gandi::DomainModules::Mail
   end
 end

data/lib/gandi/errors.rb

@@ -0,0 +1,10 @@
+module Gandi
+  class DataError < ArgumentError
+  end
+  
+  class ServerError < RuntimeError
+  end
+  
+  class NoMethodError < ::NoMethodError
+  end
+end

data/lib/gandi/gandi_object_methods.rb

@@ -0,0 +1,23 @@
+module Gandi
+  module GandiObjectMethods
+    def self.included(base)
+      base.extend Gandi::Connector
+    end
+    
+    #Returns a hash (with string keys) with the object information attributes.
+    def to_hash
+      @attributes.dup
+    end
+    
+    #Returns a string containing a human-readable representation of the object.
+    #TODO improve the output.
+    def inspect
+      @attributes.inspect
+    end
+    
+    #Returns an attribute value.
+    def [](attribute)
+      @attributes[attribute.to_s]
+    end
+  end
+end

data/lib/gandi/operation.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Gandi
+  class Operation
+    include Gandi::GandiObjectMethods
+    
+    attr_reader :id
+    
+    def initialize(operation_id, information_attributes = nil)
+      @id = operation_id
+      @attributes = information_attributes || info
+    end
+    
+    #Return some attributes of a operation visible by this account.
+    def info
+      self.class.call('operation.info', @id)
+    end
+    
+    #Set the step of an operation to CANCEL.
+    def cancel
+      result = self.class.call('operation.cancel', @id)
+      @attributes['step'] = 'CANCEL' if result
+      return result
+    end
+    
+    class << self
+      #Count operations visible by this account.
+      def count(opts = {})
+        call('operation.count', opts)
+      end
+      
+      #List operations done by this account.
+      #The array of returned operations are mapped to Operation objects unless map_operations is set to false.
+      def list(opts = {}, map_operations = true)
+        operations = call('operation.list', opts)
+        if map_operations
+          operations.map! do |operation|
+            self.new(operation['id'], operation)
+          end
+        end
+        operations
+      end
+    end
+  end
+end

data/lib/gandi/version.rb

@@ -1,3 +1,3 @@
 module Gandi
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

data/lib/gandi.rb

@@ -1,8 +1,59 @@
+require 'gandi/version'
+require 'gandi/errors'
+require 'gandi/connection'
+require 'gandi/connector'
+require 'gandi/gandi_object_methods'
+require 'gandi/operation'
+require 'gandi/contact'
+require 'gandi/domain'
+
 module Gandi
-  class DataError < ArgumentError ; end
-  class ServerError < RuntimeError ; end
-end
+  #Production URL
+  URL = "https://rpc.gandi.net/xmlrpc/"
+  
+  #OT&E URL
+  TEST_URL = "https://rpc.ote.gandi.net/xmlrpc/"
+  
+  class << self
+    #The 24-character API key used for authentication.
+    attr_reader :apikey
+    
+    #Sets the apikey for the Gandi connection.
+    #Changing it will reset the connection.
+    def apikey=(apikey)
+      @apikey = apikey
+      @connection = nil
+    end
+    
+    #The URL for the Gandi connection.
+    def url
+      @url || Gandi::TEST_URL
+    end
+    
+    #Sets the URL for the Gandi connection.
+    #Changing it will reset the connection.
+    def url=(url)
+      @url = url
+      @connection = nil
+    end
+    
+    #A Gandi::Connection object set using the provided apikey and url.
+    #This object can be overriden for testing purposes.
+    #Note that the connection object is reset if the apikey or url is changed.
+    def connection
+      @connection ||= Gandi::Connection.new(apikey, url)
+    end
+    
+    attr_writer :connection
 
-require 'gandi/base'
-require 'gandi/domain'
-require 'gandi/version'
+    #Calls a Gandi XML-RPC method, transparently providing the apikey.
+    def call(method, *arguments)
+      connection.call(method, *arguments)
+    end
+    
+    #Returns the API version from Gandi.
+    def api_version
+      Gandi.call('version.info')['api_version']
+    end
+  end
+end

data/spec/gandi/connection_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'gandi/connection'
+require 'gandi/errors'
+
+describe Gandi::Connection do
+  describe "#new" do
+    it "connects using apikey and url" do
+      gandi_connection = Gandi::Connection.new('apikey', 'http://fakedomain.tld/')
+      gandi_connection.instance_variable_get('@handler').should be_a(XMLRPC::Client)
+      gandi_connection.instance_variable_get('@handler').instance_variable_get('@host').should == 'fakedomain.tld'
+    end
+    
+    it "fails when setting a nil apikey" do
+      lambda { Gandi::Connection.new(nil, nil) }.should raise_error(Gandi::DataError)
+    end
+  end
+  
+  context "an instance" do
+    subject { Gandi::Connection.new('apikey', 'http://fakedomain.tld/') }
+    
+    its(:url) { should == 'http://fakedomain.tld/' }
+    its(:apikey) { should == 'apikey' }
+    
+    it "can call methods and transmit them to the handler" do
+      subject.instance_variable_get('@handler').should_receive(:call).once.with('method.name', 'apikey', 'arg1', 'arg2').and_return('result value')
+      subject.call('method.name', 'arg1', 'arg2').should == 'result value'
+    end
+    
+    it "maps xml-rpc 5xxxxx errors to Gandi errors" do
+      subject.instance_variable_get('@handler').should_receive(:call).once.with('contact.list', 'apikey', 'AB123-GANDI').and_raise(XMLRPC::FaultException.new('516150', "Error on object : OBJECT_CONTACT (CAUSE_NORIGHT) [You aren't allowed to read that contact]"))
+      lambda { subject.call('contact.list', 'AB123-GANDI') }.should raise_error(Gandi::DataError)
+    end
+    
+    it "maps xml-rpc errors with faultCode 1 to Gandi error" do
+      subject.instance_variable_get('@handler').should_receive(:call).once.with('unknownmethod', 'apikey').and_raise(XMLRPC::FaultException.new('1', 'Method "unknownmethod" is not supported'))
+      lambda { subject.call('unknownmethod') }.should raise_error(Gandi::NoMethodError)
+    end
+  end
+end