dnsimple-ruby 1.3.2 → 1.4.0

data/lib/dnsimple/error.rb

@@ -1,32 +1,21 @@
 module DNSimple
+
   class Error < StandardError
   end
 
-  class DomainError < DNSimple::Error
-    def initialize(domain, messages)
-      @domain = domain
-      @messages = messages
-      super "An error occurred: #{messages}"
-    end
+  class RecordExists < Error
   end
 
-  class RecordExists < DomainError
-    def initialize(domain, message)
-      super(domain, message)
-    end
+  class RecordNotFound < Error
   end
 
-  class RecordNotFound < DNSimple::Error; end
-
-  class AuthenticationFailed < DNSimple::Error
-    def initialize(message="Authentication failed")
-      super(message)
+  class RequestError < Error
+    def initialize(description, response)
+      super("#{description}: #{response["error"]}")
     end
   end
 
-  class UserNotFound < DNSimple::Error; end
-
-  class CertificateExists < DNSimple::Error; end
+  class AuthenticationFailed < Error
+  end
 
-  class CertificateNotFound < DNSimple::Error; end
 end

data/lib/dnsimple/extended_attribute.rb

@@ -1,46 +1,52 @@
-class DNSimple::ExtendedAttribute < DNSimple::Base # Used for domains that require extended attributes.
-  # An option for an extended attribute
-  class Option < DNSimple::Base
-    # The option name
-    attr_accessor :title
+module DNSimple
 
-    # The option value
-    attr_accessor :value
+  # Used for domains that require extended attributes.
+  class ExtendedAttribute < Base
 
-    # A long description of the option
-    attr_accessor :description
-  end
+    # An option for an extended attribute
+    class Option < Base
+      # The option name
+      attr_accessor :title
 
-  # The extended attribute name
-  attr_accessor :name
+      # The option value
+      attr_accessor :value
 
-  # A description of the extended attribute
-  attr_accessor :description
+      # A long description of the option
+      attr_accessor :description
+    end
 
-  # Boolean indicating if the extended attribute is required
-  attr_accessor :required
+    # The extended attribute name
+    attr_accessor :name
 
-  # An array of options for the extended attribute
-  def options
-    @options ||= []
-  end
+    # A description of the extended attribute
+    attr_accessor :description
 
-  def options=(opts)
-    @options = []
-    opts.each do |opt|
-      @options << DNSimple::ExtendedAttribute::Option.new(opt)
+    # Boolean indicating if the extended attribute is required
+    attr_accessor :required
+
+    # An array of options for the extended attribute
+    def options
+      @options ||= []
     end
-  end
 
-  # Find the extended attributes for the given TLD
-  def self.find(tld, options={})
-    response = DNSimple::Client.get "extended_attributes/#{tld}.json", options
+    def options=(opts)
+      @options = []
+      opts.each do |opt|
+        @options << DNSimple::ExtendedAttribute::Option.new(opt)
+      end
+    end
 
-    case response.code
-    when 200
-      response.map { |r| new(r) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+    # Find the extended attributes for the given TLD
+    def self.find(tld, options={})
+      response = DNSimple::Client.get("extended_attributes/#{tld}", options)
+
+      case response.code
+      when 200
+        response.map { |r| new(r) }
+      else
+        raise RequestError.new("Error finding extended attributes", response)
+      end
     end
+
   end
 end

data/lib/dnsimple/record.rb

@@ -1,95 +1,99 @@
-class DNSimple::Record < DNSimple::Base
-  Aliases = {
-    'priority'     => 'prio',
-    'time-to-live' => 'ttl'
-  }
+module DNSimple
 
-  attr_accessor :id
+  class Record < Base
+    Aliases = {
+      'priority'     => 'prio',
+      'time-to-live' => 'ttl'
+    }
 
-  attr_accessor :domain
+    attr_accessor :id
 
-  attr_accessor :name
+    attr_accessor :domain
 
-  attr_accessor :content
+    attr_accessor :name
 
-  attr_accessor :record_type
+    attr_accessor :content
 
-  attr_accessor :ttl
+    attr_accessor :record_type
 
-  attr_accessor :prio
+    attr_accessor :ttl
 
-  def fqdn
-    [name, domain.name].delete_if { |v| v !~ DNSimple::BLANK_REGEX }.join(".")
-  end
+    attr_accessor :prio
 
-  def save(options={})
-    record_hash = {}
-    %w(name content ttl prio).each do |attribute|
-      record_hash[DNSimple::Record.resolve(attribute)] = self.send(attribute)
+    def fqdn
+      [name, domain.name].delete_if { |v| v !~ DNSimple::BLANK_REGEX }.join(".")
     end
 
-    options.merge!(:body => {:record => record_hash})
+    def save(options={})
+      record_hash = {}
+      %w(name content ttl prio).each do |attribute|
+        record_hash[DNSimple::Record.resolve(attribute)] = self.send(attribute)
+      end
+
+      options.merge!(:body => {:record => record_hash})
 
-    response = DNSimple::Client.put("domains/#{domain.id}/records/#{id}.json", options)
+      response = DNSimple::Client.put("domains/#{domain.id}/records/#{id}", options)
 
-    case response.code
-    when 200
-      return self
-    else
-      raise DNSimple::Error, "Failed to update record: #{response.inspect}"
+      case response.code
+      when 200
+        self
+      else
+        raise RequestError.new("Error updating record", response)
+      end
     end
-  end
 
-  def delete(options={})
-    DNSimple::Client.delete "domains/#{domain.id}/records/#{id}", options
-  end
-  alias :destroy :delete
+    def delete(options={})
+      DNSimple::Client.delete("domains/#{domain.id}/records/#{id}", options)
+    end
+    alias :destroy :delete
 
-  def self.resolve(name)
-    DNSimple::Record::Aliases[name] || name
-  end
+    def self.resolve(name)
+      DNSimple::Record::Aliases[name] || name
+    end
 
-  def self.create(domain, name, record_type, content, options={})
-    record_hash = {:name => name, :record_type => record_type, :content => content}
-    record_hash[:ttl] = options.delete(:ttl) || 3600
-    record_hash[:prio] = options.delete(:priority)
-    record_hash[:prio] = options.delete(:prio) || ''
+    def self.create(domain, name, record_type, content, options={})
+      record_hash = {:name => name, :record_type => record_type, :content => content}
+      record_hash[:ttl] = options.delete(:ttl) || 3600
+      record_hash[:prio] = options.delete(:priority)
+      record_hash[:prio] = options.delete(:prio) || ''
 
-    options.merge!({:body => {:record => record_hash}})
+      options.merge!({:body => {:record => record_hash}})
 
-    response = DNSimple::Client.post "domains/#{domain.name}/records", options
+      response = DNSimple::Client.post("domains/#{domain.name}/records", options)
 
-    case response.code
-    when 201
-      return new({:domain => domain}.merge(response["record"]))
-    when 406
-      raise DNSimple::RecordExists.new("#{name}.#{domain.name}", response["errors"])
-    else
-      raise DNSimple::Error, "Failed to create #{name}.#{domain.name}: #{response["errors"]}"
+      case response.code
+      when 201
+        new({:domain => domain}.merge(response["record"]))
+      when 406
+        raise RecordExists, "Record #{name}.#{domain.name} already exists"
+      else
+        raise RequestError.new("Error creating record", response)
+      end
     end
-  end
-
-  def self.find(domain, id, options={})
-    response = DNSimple::Client.get("domains/#{domain.name}/records/#{id}", options)
 
-    case response.code
-    when 200
-      return new({:domain => domain}.merge(response["record"]))
-    when 404
-      raise DNSimple::RecordNotFound, "Could not find record #{id} for domain #{domain.name}"
-    else
-      raise DNSimple::Error, "Failed to find domain #{domain.name}/#{id}: #{response["errors"]}"
+    def self.find(domain, id, options={})
+      response = DNSimple::Client.get("domains/#{domain.name}/records/#{id}", options)
+
+      case response.code
+      when 200
+        new({:domain => domain}.merge(response["record"]))
+      when 404
+        raise RecordNotFound, "Could not find record #{id} for domain #{domain.name}"
+      else
+        raise RequestError.new("Error finding record", response)
+      end
     end
-  end
 
-  def self.all(domain, options={})
-    response = DNSimple::Client.get("domains/#{domain.name}/records", options)
+    def self.all(domain, options={})
+      response = DNSimple::Client.get("domains/#{domain.name}/records", options)
 
-    case response.code
-    when 200
-      response.map { |r| new({:domain => domain}.merge(r["record"])) }
-    else
-      raise DNSimple::Error, "Error listing domains: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| new({:domain => domain}.merge(r["record"])) }
+      else
+        raise RequestError.new("Error listing records", response)
+      end
     end
+
   end
 end

data/lib/dnsimple/service.rb

@@ -1,35 +1,42 @@
-class DNSimple::Service < DNSimple::Base # Class representing a service that can be applied to a domain
-  attr_accessor :id
+module DNSimple
 
-  attr_accessor :name
+  # Represents a service that can be applied to a domain.
+  class Service < Base
 
-  attr_accessor :short_name
+    attr_accessor :id
 
-  attr_accessor :description
+    attr_accessor :name
 
-  # Find a service by its ID or short name
-  def self.find(id_or_short_name, options={})
-    response = DNSimple::Client.get("services/#{id_or_short_name}.json", options)
+    attr_accessor :short_name
 
-    case response.code
-    when 200
-      return new(response["service"])
-    when 404
-      raise RuntimeError, "Could not find service #{id_or_short_name}"
-    else
-      raise DNSimple::Error.new(id_or_short_name, response["errors"])
+    attr_accessor :description
+
+    # Find a service by its ID or short name
+    def self.find(id_or_short_name, options={})
+      id = id_or_short_name
+      response = DNSimple::Client.get("services/#{id}", options)
+
+      case response.code
+      when 200
+        new(response["service"])
+      when 404
+        raise RecordNotFound, "Could not find service #{id}"
+      else
+        raise RequestError.new("Error finding service", response)
+      end
     end
-  end
 
-  # Get all of the services that can be applied to a domain
-  def self.all(options={})
-    response = DNSimple::Client.get 'services.json', options
+    # Get all of the services that can be applied to a domain
+    def self.all(options={})
+      response = DNSimple::Client.get("services", options)
 
-    case response.code
-    when 200
-      response.map { |r| new(r["service"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| new(r["service"]) }
+      else
+        raise RequestError.new("Error listing services", response)
+      end
     end
+
   end
 end

data/lib/dnsimple/template.rb

@@ -1,63 +1,69 @@
-class DNSimple::Template < DNSimple::Base
-  # The template ID in DNSimple
-  attr_accessor :id
+module DNSimple
 
-  # The template name
-  attr_accessor :name
+  class Template < Base
 
-  # The template short name
-  attr_accessor :short_name
+    # The template ID in DNSimple
+    attr_accessor :id
 
-  # The template description
-  attr_accessor :description
+    # The template name
+    attr_accessor :name
 
-  # Delete the template from DNSimple. WARNING: this cannot
-  # be undone.
-  def delete(options={})
-    DNSimple::Client.delete "templates/#{id}", options
-  end
-  alias :destroy :delete
+    # The template short name
+    attr_accessor :short_name
+
+    # The template description
+    attr_accessor :description
+
+    # Delete the template from DNSimple. WARNING: this cannot
+    # be undone.
+    def delete(options={})
+      DNSimple::Client.delete("templates/#{id}", options)
+    end
+    alias :destroy :delete
 
-  def self.create(name, short_name, description=nil, options={})
-    template_hash = {
-      :name        => name,
-      :short_name  => short_name,
-      :description => description
-    }
+    def self.create(name, short_name, description=nil, options={})
+      template_hash = {
+        :name        => name,
+        :short_name  => short_name,
+        :description => description
+      }
 
-    options.merge!(:body => {:dns_template => template_hash})
+      options.merge!(:body => {:dns_template => template_hash})
 
-    response = DNSimple::Client.post 'templates', options
+      response = DNSimple::Client.post("templates", options)
 
-    case response.code
-    when 201
-      return new(response["dns_template"])
-    else
-      raise DNSimple::Error.new(name, response["errors"])
+      case response.code
+      when 201
+        new(response["dns_template"])
+      else
+        raise RequestError.new("Error creating template", response)
+      end
     end
-  end
 
-  def self.find(id_or_short_name, options={})
-    response = DNSimple::Client.get "templates/#{id_or_short_name}", options
+    def self.find(id_or_short_name, options={})
+      id = id_or_short_name
+      response = DNSimple::Client.get("templates/#{id}", options)
 
-    case response.code
-    when 200
-      return new(response["dns_template"])
-    when 404
-      raise RuntimeError, "Could not find template #{id_or_short_name}"
-    else
-      raise DNSimple::Error.new(id_or_short_name, response["errors"])
+      case response.code
+      when 200
+        new(response["dns_template"])
+      when 404
+        raise RecordNotFound, "Could not find template #{id}"
+      else
+        raise RequestError.new("Error finding template", response)
+      end
     end
-  end
 
-  def self.all(options={})
-    response = DNSimple::Client.get 'templates', options
+    def self.all(options={})
+      response = DNSimple::Client.get("templates", options)
 
-    case response.code
-    when 200
-      response.map { |r| new(r["dns_template"]) }
-    else
-      raise RuntimeError, "Error: #{response.code}"
+      case response.code
+      when 200
+        response.map { |r| new(r["dns_template"]) }
+      else
+        raise RequestError.new("Error listing templates", response)
+      end
     end
+
   end
 end