dnsimple-ruby 1.2.6 → 1.3.0

data/lib/dnsimple/domain.rb

@@ -1,220 +1,171 @@
-module DNSimple #:nodoc:
-  # Class representing a single domain in DNSimple.
-  class Domain
-    include HTTParty
-
-    # The domain ID in DNSimple
-    attr_accessor :id
-    
-    # The domain name
-    attr_accessor :name
-    
-    # When the domain was created in DNSimple
-    attr_accessor :created_at
-    
-    # When the domain was last update in DNSimple
-    attr_accessor :updated_at
-
-    # The current known name server status
-    attr_accessor :name_server_status
-
-    #:nodoc:
-    def initialize(attributes)
-      attributes.each do |key, value|
-        m = "#{key}=".to_sym
-        self.send(m, value) if self.respond_to?(m)
-      end
-    end
+class DNSimple::Domain < DNSimple::Base # Class representing a single domain in DNSimple.
+  # The domain ID in DNSimple
+  attr_accessor :id
 
-    # Delete the domain from DNSimple. WARNING: this cannot
-    # be undone.
-    def delete(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      self.class.delete("#{DNSimple::Client.base_uri}/domains/#{name}", options)
-    end
-    alias :destroy :delete
-
-    # 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!(DNSimple::Client.standard_options_with_credentials)
-      options.merge!(:body => {})
-      template = resolve_template(template)
-      self.class.post("#{DNSimple::Client.base_uri}/domains/#{name}/templates/#{template.id}/apply", options)
-    end
+  # The domain name
+  attr_accessor :name
 
-    #:nodoc:
-    def resolve_template(template)
-      case template
-      when DNSimple::Template
-        template
-      else
-        DNSimple::Template.find(template)
-      end
+  # When the domain was created in DNSimple
+  attr_accessor :created_at
+
+  # When the domain was last update in DNSimple
+  attr_accessor :updated_at
+
+  # The current known name server status
+  attr_accessor :name_server_status
+
+  # Delete the domain from DNSimple. WARNING: this cannot
+  # be undone.
+  def delete(options={})
+    DNSimple::Client.delete "domains/#{name}", options
+  end
+  alias :destroy :delete
+
+  # 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)
+
+    DNSimple::Client.post "domains/#{name}/templates/#{template.id}/apply",
+      options
+  end
+
+  #:nodoc:
+  def resolve_template(template)
+    case template
+    when DNSimple::Template
+      template
+    else
+      DNSimple::Template.find(template)
     end
+  end
 
-    def applied_services(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.class.get("#{Client.base_uri}/domains/#{name}/applied_services", options)
-      pp response if DNSimple::Client.debug?
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Service.new(r["service"]) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      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}"
     end
+  end
 
-    def available_services(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.class.get("#{DNSimple::Client.base_uri}/domains/#{name}/available_services", options)
-      pp response if DNSimple::Client.debug?
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Service.new(r["service"]) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      end
+  def available_services(options={})
+    response = DNSimple::Client.get "domains/#{name}/available_services",
+      options
+
+    case response.code
+    when 200
+      response.map { |r| DNSimple::Service.new(r["service"]) }
+    else
+      raise RuntimeError, "Error: #{response.code}"
     end
+  end
 
-    def add_service(id_or_short_name, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      options.merge!(:body => {:service => {:id => id_or_short_name}})
-      response = self.class.post("#{DNSimple::Client.base_uri}/domains/#{name}/applied_services", options)
-      pp response if DNSimple::Client.debug?
-      case response.code
-      when 200
-        true
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise "Error: #{response.code}"
-      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
+
+    case response.code
+    when 200
+      true
+    else
+      raise "Error: #{response.code}"
     end
+  end
 
-    def remove_service(id, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.class.delete("#{DNSimple::Client.base_uri}/domains/#{name}/applied_services/#{id}", options)
-      pp response if DNSimple::Client.debug?
-      case response.code
-      when 200
-        true
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise "Error: #{response.code}"
-      end
+  def remove_service(id, options={})
+    response = DNSimple::Client.delete("domains/#{name}/applied_services/#{id}", options)
+
+    case response.code
+    when 200
+      true
+    else
+      raise "Error: #{response.code}"
     end
+  end
 
-    # Check the availability of a name
-    def self.check(name, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{DNSimple::Client.base_uri}/domains/#{name}/check", options)
-      pp response if DNSimple::Client.debug?
-      case response.code
-      when 200
-        "registered"
-      when 401
-        raise RuntimeError, "Authentication failed"
-      when 404
-        "available"
-      else
-        raise "Error: #{response.code}" 
-      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
 
-    # 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!(DNSimple::Client.standard_options_with_credentials)
-
-      domain_hash = {:name => name}
-      options.merge!({:body => {:domain => domain_hash}})
-
-      response = self.post("#{DNSimple::Client.base_uri}/domains", options)
-      
-      pp response if DNSimple::Client.debug?
-      
-      case response.code
-      when 201
-        return DNSimple::Domain.new(response["domain"])
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise DNSimple::DomainError.new(name, response["errors"])
-      end
+  # 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
+      return new(response["domain"])
+    else
+      raise DNSimple::DomainError.new(name, response["errors"])
     end
+  end
 
-    # Purchase a domain name.
-    def self.register(name, registrant={}, extended_attributes={}, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-
-      body = {:domain => {:name => name}}
-      if registrant
-        if registrant[:id]
-          body[:domain][:registrant_id] = registrant[:id]
-        else
-          body.merge!(:contact => Contact.resolve_attributes(registrant))
-        end
-      end
-      body.merge!(:extended_attribute => extended_attributes)
-      options.merge!({:body => body})
-      
-      response = self.post("#{DNSimple::Client.base_uri}/domain_registrations", options)
-      
-      pp response if DNSimple::Client.debug?
-      
-      case response.code
-      when 201
-        return DNSimple::Domain.new(response["domain"])
-      when 401
-        raise RuntimeError, "Authentication failed"
+  # 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
-        raise DNSimple::DomainError.new(name, response["errors"])
+        body.merge!(:contact => DNSimple::Contact.resolve_attributes(registrant))
       end
     end
+    body.merge!(:extended_attribute => extended_attributes)
+    options.merge!({:body => body})
 
-    # 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={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{DNSimple::Client.base_uri}/domains/#{id_or_name}", options)
-      
-      pp response if DNSimple::Client.debug?
-      
-      case response.code
-      when 200
-        return DNSimple::Domain.new(response["domain"])
-      when 401
-        raise RuntimeError, "Authentication failed"
-      when 404
-        raise RuntimeError, "Could not find domain #{id_or_name}"
-      else
-        raise DNSimple::DomainError.new(id_or_name, response["errors"])
-      end
+    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"])
     end
+  end
 
-    # Get all domains for the account.
-    def self.all(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{DNSimple::Client.base_uri}/domains", options)
-      
-      pp response if DNSimple::Client.debug?
-
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Domain.new(r["domain"]) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      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"])
     end
+  end
+
+  # 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}"
+    end
   end
 end

data/lib/dnsimple/extended_attribute.rb

@@ -1,73 +1,46 @@
-module DNSimple #:nodoc:
-  # Used for domains that require extended attributes.
-  class ExtendedAttribute
-    # An option for an extended attribute
-    class Option
-      # The option name
-      attr_accessor :title
+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
 
-      # The option value
-      attr_accessor :value
+    # The option value
+    attr_accessor :value
 
-      # A long description of the option
-      attr_accessor :description
-
-      #:nodoc:
-      def initialize(attributes)
-        attributes.each do |key, value|
-          m = "#{key}=".to_sym
-          self.send(m, value) if self.respond_to?(m)
-        end
-      end
-    end
-
-    include HTTParty
-
-    # The extended attribute name
-    attr_accessor :name
-
-    # A description of the extended attribute
+    # 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
 
-    #:nodoc:
-    def initialize(attributes)
-      attributes.each do |key, value|
-        m = "#{key}=".to_sym
-        self.send(m, value) if self.respond_to?(m)
-      end
-    end
+  # A description of the extended attribute
+  attr_accessor :description
 
-    # An array of options for the extended attribute 
-    def options
-      @options ||= []
-    end
+  # Boolean indicating if the extended attribute is required
+  attr_accessor :required
 
-    def options=(opts)
-      @options = []
-      opts.each do |opt|
-        @options << Option.new(opt)
-      end
-    end
+  # An array of options for the extended attribute
+  def options
+    @options ||= []
+  end
 
-    # Find the extended attributes for the given TLD
-    def self.find(tld, options={})
-      options.merge!({:basic_auth => Client.credentials})
-      
-      response = self.get("#{Client.base_uri}/extended_attributes/#{tld}", options)
+  def options=(opts)
+    @options = []
+    opts.each do |opt|
+      @options << DNSimple::ExtendedAttribute::Option.new(opt)
+    end
+  end
 
-      pp response if Client.debug?
+  # Find the extended attributes for the given TLD
+  def self.find(tld, options={})
+    response = DNSimple::Client.get "extended_attributes/#{tld}.json", options
 
-      case response.code
-      when 200
-        response.map { |r| ExtendedAttribute.new(r) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      end
+    case response.code
+    when 200
+      response.map { |r| new(r) }
+    else
+      raise RuntimeError, "Error: #{response.code}"
     end
   end
 end