dnsimple-ruby 1.3.2 → 1.4.0

data/lib/dnsimple/commands/{list_template_records.rb → template_record_list.rb}

@@ -1,7 +1,7 @@
 module DNSimple
   module Commands
-    class ListTemplateRecords
-      def execute(args, options={})
+    class TemplateRecordList
+      def execute(args, options = {})
         short_name = args.shift
         template_records = TemplateRecord.all(short_name)
         puts "Found #{template_records.length} records for #{short_name}"

data/lib/dnsimple/commands/{list_templates.rb → templates_list.rb}

@@ -1,7 +1,7 @@
 module DNSimple
   module Commands
-    class ListTemplates
-      def execute(args, options={})
+    class TemplateList
+      def execute(args, options = {})
         templates = Template.all
         puts "Found #{templates.length} templates:"
         templates.each do |template|

data/lib/dnsimple/contact.rb

@@ -1,148 +1,153 @@
-class DNSimple::Contact < DNSimple::Base # Class representing a contact in DNSimple
+module DNSimple
 
-  Aliases = {
-    'first'             => 'first_name',
-    'last'              => 'last_name',
-    'state'             => 'state_province',
-    'province'          => 'state_province',
-    'state_or_province' => 'state_province',
-    'email'             => 'email_address',
-  }
+  # Represents a contact.
+  class Contact < Base
 
-  # The contact ID in DNSimple
-  attr_accessor :id
+    Aliases = {
+      'first'             => 'first_name',
+      'last'              => 'last_name',
+      'state'             => 'state_province',
+      'province'          => 'state_province',
+      'state_or_province' => 'state_province',
+      'email'             => 'email_address',
+    }
 
-  # The name of the organization in which the contact works
-  # (may be omitted)
-  attr_accessor :organization_name
+    # The contact ID in DNSimple
+    attr_accessor :id
 
-  # The contact first name
-  attr_accessor :first_name
+    # The name of the organization in which the contact works
+    # (may be omitted)
+    attr_accessor :organization_name
 
-  # The contact last name
-  attr_accessor :last_name
+    # The contact first name
+    attr_accessor :first_name
 
-  # The contact's job title (may be omitted)
-  attr_accessor :job_title
+    # The contact last name
+    attr_accessor :last_name
 
-  # The contact street address
-  attr_accessor :address1
+    # The contact's job title (may be omitted)
+    attr_accessor :job_title
 
-  # Apartment or suite number
-  attr_accessor :address2
+    # The contact street address
+    attr_accessor :address1
 
-  # The city name
-  attr_accessor :city
+    # Apartment or suite number
+    attr_accessor :address2
 
-  # The state or province name
-  attr_accessor :state_province
+    # The city name
+    attr_accessor :city
 
-  # The contact postal code
-  attr_accessor :postal_code
+    # The state or province name
+    attr_accessor :state_province
 
-  # The contact country (as a 2-character country code)
-  attr_accessor :country
+    # The contact postal code
+    attr_accessor :postal_code
 
-  # The contact email address
-  attr_accessor :email_address
+    # The contact country (as a 2-character country code)
+    attr_accessor :country
 
-  # The contact phone number
-  attr_accessor :phone
+    # The contact email address
+    attr_accessor :email_address
 
-  # The contact phone extension (may be omitted)
-  attr_accessor :phone_ext
+    # The contact phone number
+    attr_accessor :phone
 
-  # The contact fax number (may be omitted)
-  attr_accessor :fax
+    # The contact phone extension (may be omitted)
+    attr_accessor :phone_ext
 
-  # When the contact was created in DNSimple
-  attr_accessor :created_at
+    # The contact fax number (may be omitted)
+    attr_accessor :fax
 
-  # When the contact was last updated in DNSimple
-  attr_accessor :updated_at
+    # When the contact was created in DNSimple
+    attr_accessor :created_at
 
-  def name
-    [first_name, last_name].join(' ')
-  end
+    # When the contact was last updated in DNSimple
+    attr_accessor :updated_at
 
-  def save(options={})
-    contact_hash = {}
-    %w(first_name last_name organization_name job_title address1 address2 city
-    state_province postal_code country email_address phone phone_ext fax).each do |attribute|
-      contact_hash[DNSimple::Contact.resolve(attribute)] = self.send(attribute)
+    def name
+      [first_name, last_name].join(' ')
     end
 
-    options.merge!({:body => {:contact => contact_hash}})
-
-    response = DNSimple::Client.put("contacts/#{id}", options)
+    def save(options={})
+      contact_hash = {}
+      %w(first_name last_name organization_name job_title address1 address2 city
+      state_province postal_code country email_address phone phone_ext fax).each do |attribute|
+        contact_hash[DNSimple::Contact.resolve(attribute)] = self.send(attribute)
+      end
 
-    case response.code
-    when 200
-      return self
-    else
-      raise RuntimeError, "Failed to update contact: #{response.inspect}"
-    end
-  end
+      options.merge!({:body => {:contact => contact_hash}})
 
-  # Delete the contact from DNSimple. WARNING: this cannot be undone.
-  def delete(options={})
-    DNSimple::Client.delete("contacts/#{id}.json", options)
-  end
-  alias :destroy :delete
-
-  # Map an aliased field name to it's real name. For example, if you
-  # pass "first" it will be resolved to "first_name", "email" is resolved
-  # to "email_address" and so on.
-  def self.resolve(name)
-    DNSimple::Contact::Aliases[name.to_s] || name
-  end
+      response = DNSimple::Client.put("contacts/#{id}", options)
 
-  def self.resolve_attributes(attributes)
-    resolved_attributes = {}
-    attributes.each do |k, v|
-      resolved_attributes[resolve(k)] = v
+      case response.code
+      when 200
+        return self
+      else
+        raise RequestError.new("Error updating contact", response)
+      end
     end
-    resolved_attributes
-  end
 
-  # Create the contact with the given attributes in DNSimple.
-  # This method returns a Contact instance of the contact is created
-  # and raises an error otherwise.
-  def self.create(attributes, options={})
-    contact_hash = resolve_attributes(attributes)
+    # Delete the contact from DNSimple. WARNING: this cannot be undone.
+    def delete(options={})
+      DNSimple::Client.delete("contacts/#{id}", options)
+    end
+    alias :destroy :delete
 
-    options.merge!({:body => {:contact => contact_hash}})
-    response = DNSimple::Client.post 'contacts.json', options
+    # Map an aliased field name to it's real name. For example, if you
+    # pass "first" it will be resolved to "first_name", "email" is resolved
+    # to "email_address" and so on.
+    def self.resolve(name)
+      DNSimple::Contact::Aliases[name.to_s] || name
+    end
 
-    case response.code
-    when 201
-      return new(response["contact"])
-    else
-      raise RuntimeError, "Failed to create contact: #{response.inspect}"
+    def self.resolve_attributes(attributes)
+      resolved_attributes = {}
+      attributes.each do |k, v|
+        resolved_attributes[resolve(k)] = v
+      end
+      resolved_attributes
     end
-  end
 
-  def self.find(id, options={})
-    response = DNSimple::Client.get "contacts/#{id}.json", options
+    # Create the contact with the given attributes in DNSimple.
+    # This method returns a Contact instance of the contact is created
+    # and raises an error otherwise.
+    def self.create(attributes, options={})
+      contact_hash = resolve_attributes(attributes)
+
+      options.merge!({:body => {:contact => contact_hash}})
+      response = DNSimple::Client.post("contacts", options)
+
+      case response.code
+      when 201
+        new(response["contact"])
+      else
+        raise RequestError.new("Error creating contact", response)
+      end
+    end
 
-    case response.code
-    when 200
-      return new(response["contact"])
-    when 404
-      raise RuntimeError, "Could not find contact #{id}"
-    else
-      raise DNSimple::Error.new(id, response["errors"])
+    def self.find(id, options={})
+      response = DNSimple::Client.get("contacts/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["contact"])
+      when 404
+        raise RecordNotFound, "Could not find contact #{id}"
+      else
+        raise RequestError.new("Error finding contact", response)
+      end
     end
-  end
 
-  def self.all(options={})
-    response = DNSimple::Client.get 'contacts.json', options
+    def self.all(options={})
+      response = DNSimple::Client.get("contacts", options)
 
-    case response.code
-    when 200
-      response.map { |r| new(r["contact"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| new(r["contact"]) }
+      else
+        raise RequestError.new("Error listing contacts", response)
+      end
     end
+
   end
 end

data/lib/dnsimple/domain.rb

@@ -1,171 +1,173 @@
-class DNSimple::Domain < DNSimple::Base # Class representing a single domain in DNSimple.
-  # The domain ID in DNSimple
-  attr_accessor :id
+module DNSimple
 
-  # The domain name
-  attr_accessor :name
+  # Represents a single domain.
+  class Domain < Base
+    # The domain ID in DNSimple
+    attr_accessor :id
 
-  # When the domain was created in DNSimple
-  attr_accessor :created_at
+    # The domain name
+    attr_accessor :name
 
-  # When the domain was last update in DNSimple
-  attr_accessor :updated_at
+    # When the domain was created in DNSimple
+    attr_accessor :created_at
 
-  # The current known name server status
-  attr_accessor :name_server_status
+    # When the domain was last update in DNSimple
+    attr_accessor :updated_at
 
-  # Delete the domain from DNSimple. WARNING: this cannot
-  # be undone.
-  def delete(options={})
-    DNSimple::Client.delete "domains/#{name}", options
-  end
-  alias :destroy :delete
+    # The current known name server status
+    attr_accessor :name_server_status
 
-  # Apply the given named template to the domain. This will add
-  # all of the records in the template to the domain.
-  def apply(template, options={})
-    options.merge!(:body => {})
-    template = resolve_template(template)
+    # Delete the domain from DNSimple. WARNING: this cannot
+    # be undone.
+    def delete(options={})
+      DNSimple::Client.delete("domains/#{name}", options)
+    end
+    alias :destroy :delete
 
-    DNSimple::Client.post "domains/#{name}/templates/#{template.id}/apply",
-      options
-  end
+    # Apply the given named template to the domain. This will add
+    # all of the records in the template to the domain.
+    def apply(template, options={})
+      options.merge!(:body => {})
+      template = resolve_template(template)
 
-  #:nodoc:
-  def resolve_template(template)
-    case template
-    when DNSimple::Template
-      template
-    else
-      DNSimple::Template.find(template)
+      DNSimple::Client.post("domains/#{name}/templates/#{template.id}/apply", options)
     end
-  end
-
-  def applied_services(options={})
-    response = DNSimple::Client.get "domains/#{name}/applied_services",
-      options
 
-    case response.code
-    when 200
-      response.map { |r| DNSimple::Service.new(r["service"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+    #:nodoc:
+    def resolve_template(template)
+      case template
+      when DNSimple::Template
+        template
+      else
+        DNSimple::Template.find(template)
+      end
     end
-  end
 
-  def available_services(options={})
-    response = DNSimple::Client.get "domains/#{name}/available_services",
-      options
+    def applied_services(options={})
+      response = DNSimple::Client.get("domains/#{name}/applied_services", options)
 
-    case response.code
-    when 200
-      response.map { |r| DNSimple::Service.new(r["service"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      else
+        raise RequestError.new("Error listing applied services", response)
+      end
     end
-  end
 
-  def add_service(id_or_short_name, options={})
-    options.merge!(:body => {:service => {:id => id_or_short_name}})
-    response = DNSimple::Client.post "domains/#{name}/applied_services",
-      options
+    def available_services(options={})
+      response = DNSimple::Client.get("domains/#{name}/available_services", options)
 
-    case response.code
-    when 200
-      true
-    else
-      raise "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| DNSimple::Service.new(r["service"]) }
+      else
+        raise RequestError.new("Error listing available services", response)
+      end
     end
-  end
 
-  def remove_service(id, options={})
-    response = DNSimple::Client.delete("domains/#{name}/applied_services/#{id}", options)
+    def add_service(id_or_short_name, options={})
+      options.merge!(:body => {:service => {:id => id_or_short_name}})
+      response = DNSimple::Client.post("domains/#{name}/applied_services", options)
 
-    case response.code
-    when 200
-      true
-    else
-      raise "Error: #{response.code}"
+      case response.code
+      when 200
+        true
+      else
+        raise RequestError.new("Error adding service", response)
+      end
     end
-  end
 
-  # Check the availability of a name
-  def self.check(name, options={})
-    response = DNSimple::Client.get("domains/#{name}/check", options)
-
-    case response.code
-    when 200
-      "registered"
-    when 404
-      "available"
-    else
-      raise "Error: #{response.code}"
-    end
-  end
+    def remove_service(id, options={})
+      response = DNSimple::Client.delete("domains/#{name}/applied_services/#{id}", options)
 
-  # Create the domain with the given name in DNSimple. This
-  # method returns a Domain instance if the name is created
-  # and raises an error otherwise.
-  def self.create(name, options={})
-    options.merge!({:body => {:domain => {:name => name}}})
+      case response.code
+      when 200
+        true
+      else
+        raise RequestError.new("Error removing service", response)
+      end
+    end
 
-    response = DNSimple::Client.post('domains', options)
+    # Check the availability of a name
+    def self.check(name, options={})
+      response = DNSimple::Client.get("domains/#{name}/check", options)
 
-    case response.code
-    when 201
-      return new(response["domain"])
-    else
-      raise DNSimple::DomainError.new(name, response["errors"])
+      case response.code
+      when 200
+        "registered"
+      when 404
+        "available"
+      else
+        raise RequestError.new("Error checking availability", response)
+      end
     end
-  end
 
-  # Purchase a domain name.
-  def self.register(name, registrant={}, extended_attributes={}, options={})
-    body = {:domain => {:name => name}}
-    if registrant
-      if registrant[:id]
-        body[:domain][:registrant_id] = registrant[:id]
+    # Create the domain with the given name in DNSimple. This
+    # method returns a Domain instance if the name is created
+    # and raises an error otherwise.
+    def self.create(name, options={})
+      options.merge!({:body => {:domain => {:name => name}}})
+
+      response = DNSimple::Client.post("domains", options)
+
+      case response.code
+      when 201
+        new(response["domain"])
       else
-        body.merge!(:contact => DNSimple::Contact.resolve_attributes(registrant))
+        raise RequestError.new("Error creating domain", response)
       end
     end
-    body.merge!(:extended_attribute => extended_attributes)
-    options.merge!({:body => body})
 
-    response = DNSimple::Client.post('domain_registrations', options)
+    # Purchase a domain name.
+    def self.register(name, registrant={}, extended_attributes={}, options={})
+      body = {:domain => {:name => name}}
+      if registrant
+        if registrant[:id]
+          body[:domain][:registrant_id] = registrant[:id]
+        else
+          body.merge!(:contact => DNSimple::Contact.resolve_attributes(registrant))
+        end
+      end
+      body.merge!(:extended_attribute => extended_attributes)
+      options.merge!({:body => body})
+
+      response = DNSimple::Client.post("domain_registrations", options)
 
-    case response.code
-    when 201
-      return DNSimple::Domain.new(response["domain"])
-    else
-      raise DNSimple::DomainError.new(name, response["errors"])
+      case response.code
+      when 201
+        return DNSimple::Domain.new(response["domain"])
+      else
+        raise RequestError.new("Error registering domain", response)
+      end
     end
-  end
 
-  # Find a specific domain in the account either by the numeric ID
-  # or by the fully-qualified domain name.
-  def self.find(id_or_name, options={})
-    response = DNSimple::Client.get "domains/#{id_or_name}", options
-
-    case response.code
-    when 200
-      return new(response["domain"])
-    when 404
-      raise RuntimeError, "Could not find domain #{id_or_name}"
-    else
-      raise DNSimple::Error.new(id_or_name, response["errors"])
+    # Find a specific domain in the account either by the numeric ID
+    # or by the fully-qualified domain name.
+    def self.find(id_or_name, options={})
+      id = id_or_name
+      response = DNSimple::Client.get("domains/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["domain"])
+      when 404
+        raise RecordNotFound, "Could not find domain #{id}"
+      else
+        raise RequestError.new("Error finding domain", response)
+      end
     end
-  end
 
-  # Get all domains for the account.
-  def self.all(options={})
-    response = DNSimple::Client.get 'domains', options
+    # Get all domains for the account.
+    def self.all(options={})
+      response = DNSimple::Client.get("domains", options)
 
-    case response.code
-    when 200
-      response.map { |r| new(r["domain"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| new(r["domain"]) }
+      else
+        raise RequestError.new("Error listing domains", response)
+      end
     end
+
   end
 end