dnsimple-ruby 1.2.6 → 1.3.0

data/lib/dnsimple/record.rb

@@ -1,128 +1,95 @@
-module DNSimple
-  class Record
-    include HTTParty
+class DNSimple::Record < DNSimple::Base
+  Aliases = {
+    'priority'     => 'prio',
+    'time-to-live' => 'ttl'
+  }
 
-    attr_accessor :id
+  attr_accessor :id
 
-    attr_accessor :domain
+  attr_accessor :domain
 
-    attr_accessor :name
+  attr_accessor :name
 
-    attr_accessor :content
+  attr_accessor :content
 
-    attr_accessor :record_type
+  attr_accessor :record_type
 
-    attr_accessor :ttl
+  attr_accessor :ttl
 
-    attr_accessor :prio
+  attr_accessor :prio
 
-    #:nodoc:
-    def initialize(attributes)
-      attributes.each do |key, value|
-        m = "#{key}=".to_sym
-        self.send(m, value) if self.respond_to?(m)
-      end
+  def fqdn
+    [name, domain.name].delete_if { |v| v !~ DNSimple::BLANK_REGEX }.join(".")
+  end
+
+  def save(options={})
+    record_hash = {}
+    %w(name content ttl prio).each do |attribute|
+      record_hash[DNSimple::Record.resolve(attribute)] = self.send(attribute)
     end
 
-    def fqdn
-      [name, domain.name].delete_if { |v| v !~ DNSimple::BLANK_REGEX }.join(".")
+    options.merge!(:body => {:record => record_hash})
+
+    response = DNSimple::Client.put("domains/#{domain.id}/records/#{id}.json", options)
+
+    case response.code
+    when 200
+      return self
+    else
+      raise DNSimple::Error, "Failed to update record: #{response.inspect}"
     end
+  end
 
-    def save(options={})
-      record_hash = {}
-      %w(name content ttl prio).each do |attribute|
-        record_hash[DNSimple::Record.resolve(attribute)] = self.send(attribute)
-      end
+  def delete(options={})
+    DNSimple::Client.delete "domains/#{domain.id}/records/#{id}", options
+  end
+  alias :destroy :delete
 
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      options.merge!(:body => {:record => record_hash})
+  def self.resolve(name)
+    DNSimple::Record::Aliases[name] || name
+  end
 
-      response = self.class.put("#{DNSimple::Client.base_uri}/domains/#{domain.id}/records/#{id}.json", options)
+  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) || ''
 
-      pp response if DNSimple::Client.debug?
+    options.merge!({:body => {:record => record_hash}})
 
-      case response.code
-      when 200
-        return self
-      when 401
-        raise DNSimple::AuthenticationFailed
-      else
-        raise DNSimple::Error, "Failed to update record: #{response.inspect}" 
-      end
-    end
-    
-    def delete(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      self.class.delete("#{DNSimple::Client.base_uri}/domains/#{domain.id}/records/#{id}", options)
-    end
-    alias :destroy :delete
-
-    def self.resolve(name)
-      aliases = {
-        'priority' => 'prio',
-        'time-to-live' => 'ttl'
-      }
-      aliases[name] || name
-    end
+    response = DNSimple::Client.post "domains/#{domain.name}/records", options
 
-    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!(DNSimple::Client.standard_options_with_credentials)
-      options.merge!({:body => {:record => record_hash}})
-
-      response = self.post("#{DNSimple::Client.base_uri}/domains/#{domain.name}/records", options) 
-
-      pp response if DNSimple::Client.debug?
-
-      case response.code
-      when 201
-        return DNSimple::Record.new({:domain => domain}.merge(response["record"]))
-      when 401
-        raise DNSimple::AuthenticationFailed
-      when 406
-        raise DNSimple::RecordExists.new("#{name}.#{domain.name}", response["errors"])
-      else
-        raise DNSimple::Error, "Failed to create #{name}.#{domain.name}: #{response["errors"]}"
-      end
+    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"]}"
     end
+  end
 
-    def self.find(domain, id, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{DNSimple::Client.base_uri}/domains/#{domain.name}/records/#{id}", options)
-
-      pp response if DNSimple::Client.debug?
-
-      case response.code
-      when 200
-        return DNSimple::Record.new({:domain => domain}.merge(response["record"]))
-      when 401
-        raise DNSimple::AuthenticationFailed
-      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"]}"
-      end
-    end
+  def self.find(domain, id, options={})
+    response = DNSimple::Client.get("domains/#{domain.name}/records/#{id}", options)
 
-    def self.all(domain, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{DNSimple::Client.base_uri}/domains/#{domain.name}/records", 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"]}"
+    end
+  end
 
-      pp response if DNSimple::Client.debug?
+  def self.all(domain, options={})
+    response = DNSimple::Client.get("domains/#{domain.name}/records", options)
 
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Record.new({:domain => domain}.merge(r["record"])) }
-      when 401
-        raise DNSimple::AuthenticationFailed, "Authentication failed"
-      else
-        raise DNSimple::Error, "Error listing domains: #{response.code}"
-      end
+    case response.code
+    when 200
+      response.map { |r| new({:domain => domain}.merge(r["record"])) }
+    else
+      raise DNSimple::Error, "Error listing domains: #{response.code}"
     end
-
   end
 end

data/lib/dnsimple/service.rb

@@ -1,58 +1,35 @@
-module DNSimple #:nodoc:
-  # Class representing a service that can be applied to a domain
-  class Service
-    include HTTParty
+class DNSimple::Service < DNSimple::Base # Class representing a service that can be applied to a domain
+  attr_accessor :id
 
-    attr_accessor :id
+  attr_accessor :name
 
-    attr_accessor :name
+  attr_accessor :short_name
 
-    attr_accessor :short_name
+  attr_accessor :description
 
-    attr_accessor :description
+  # 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)
 
-     #:nodoc:
-    def initialize(attributes)
-      attributes.each do |key, value|
-        m = "#{key}=".to_sym
-        self.send(m, value) if self.respond_to?(m)
-      end
-    end
-
-    # Find a service by its ID or short name
-    def self.find(id_or_short_name, options={})
-      options.merge!({:basic_auth => Client.credentials})
-      response = self.get("#{Client.base_uri}/services/#{id_or_short_name}.json", options)
-      
-      pp response if Client.debug?
-      
-      case response.code
-      when 200
-        return Service.new(response["service"])
-      when 401
-        raise RuntimeError, "Authentication failed"
-      when 404
-        raise RuntimeError, "Could not find service #{id_or_short_name}"
-      else
-        raise DNSimple::Error.new(id_or_short_name, response["errors"])
-      end
+    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"])
     end
+  end
 
-    # Get all of the services that can be applied to a domain
-    def self.all(options={})
-      options.merge!({:basic_auth => Client.credentials})
-      response = self.get("#{Client.base_uri}/services.json", options)
-      
-      pp response if Client.debug?
+  # Get all of the services that can be applied to a domain
+  def self.all(options={})
+    response = DNSimple::Client.get 'services.json', options
 
-      case response.code
-      when 200
-        response.map { |r| Service.new(r["service"]) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      end
+    case response.code
+    when 200
+      response.map { |r| new(r["service"]) }
+    else
+      raise RuntimeError, "Error: #{response.code}"
     end
   end
 end

data/lib/dnsimple/template.rb

@@ -1,91 +1,63 @@
-module DNSimple
-  class Template
-    include HTTParty
+class DNSimple::Template < DNSimple::Base
+  # The template ID in DNSimple
+  attr_accessor :id
 
-    # The template ID in DNSimple
-    attr_accessor :id
-    
-    # The template name
-    attr_accessor :name
+  # The template name
+  attr_accessor :name
 
-    # The template short name
-    attr_accessor :short_name
+  # The template short name
+  attr_accessor :short_name
 
-    # The template description
-    attr_accessor :description
+  # The template description
+  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
-    
-    # Delete the template from DNSimple. WARNING: this cannot
-    # be undone.
-    def delete(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      self.class.delete("#{Client.base_uri}/templates/#{id}", options)
-    end
-    alias :destroy :delete
-
-    def self.create(name, short_name, description=nil, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      template_hash = {
-        :name => name, 
-        :short_name => short_name,
-        :description => description
-      }
+  # Delete the template from DNSimple. WARNING: this cannot
+  # be undone.
+  def delete(options={})
+    DNSimple::Client.delete "templates/#{id}", options
+  end
+  alias :destroy :delete
 
-      options.merge!(:body => {:dns_template => template_hash})
+  def self.create(name, short_name, description=nil, options={})
+    template_hash = {
+      :name        => name,
+      :short_name  => short_name,
+      :description => description
+    }
 
-      response = self.post("#{Client.base_uri}/templates", options)
+    options.merge!(:body => {:dns_template => template_hash})
 
-      pp response if Client.debug?
+    response = DNSimple::Client.post 'templates', options
 
-      case response.code
-      when 201
-        return Template.new(response["dns_template"])
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise DNSimple::Error.new(name, response["errors"])
-      end
+    case response.code
+    when 201
+      return new(response["dns_template"])
+    else
+      raise DNSimple::Error.new(name, response["errors"])
     end
+  end
 
-    def self.find(id_or_short_name, options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{Client.base_uri}/templates/#{id_or_short_name}", options)
-      
-      pp response if Client.debug?
-      
-      case response.code
-      when 200
-        return Template.new(response["dns_template"])
-      when 401
-        raise RuntimeError, "Authentication failed"
-      when 404
-        raise RuntimeError, "Could not find template #{id_or_short_name}"
-      else
-        raise DNSimple::Error.new(id_or_short_name, response["errors"])
-      end
-    end
+  def self.find(id_or_short_name, options={})
+    response = DNSimple::Client.get "templates/#{id_or_short_name}", options
 
-    def self.all(options={})
-      options.merge!(DNSimple::Client.standard_options_with_credentials)
-      response = self.get("#{Client.base_uri}/templates", 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"])
+    end
+  end
 
-      pp response if Client.debug?
+  def self.all(options={})
+    response = DNSimple::Client.get 'templates', options
 
-      case response.code
-      when 200
-        response.map { |r| Template.new(r["dns_template"]) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      end
+    case response.code
+    when 200
+      response.map { |r| new(r["dns_template"]) }
+    else
+      raise RuntimeError, "Error: #{response.code}"
     end
   end
 end

data/lib/dnsimple/template_record.rb

@@ -1,103 +1,72 @@
-module DNSimple #:nodoc:
-  # A single record in a template
-  class TemplateRecord
-    include HTTParty
+class DNSimple::TemplateRecord < DNSimple::Base # A single record in a template
+  # The id of the template record
+  attr_accessor :id
 
-    # The id of the template record
-    attr_accessor :id
+  # The template the record belongs to
+  attr_accessor :template
 
-    # The template the record belongs to
-    attr_accessor :template
+  # The name the record points to. This may be blank.
+  attr_accessor :name
 
-    # The name the record points to. This may be blank.
-    attr_accessor :name
+  # The content for the record.
+  attr_accessor :content
 
-    # The content for the record.
-    attr_accessor :content
+  # The record type
+  attr_accessor :record_type
 
-    # The record type
-    attr_accessor :record_type
+  # The time-to-live
+  attr_accessor :ttl
 
-    # The time-to-live
-    attr_accessor :ttl
+  # The priority (only for MX records)
+  attr_accessor :prio
 
-    # The priority (only for MX records)
-    attr_accessor :prio
-
-    #:nodoc:
-    def initialize(attributes)
-      attributes.each do |key, value|
-        m = "#{key}=".to_sym
-        self.send(m, value) if self.respond_to?(m)
-      end
-    end
-
-    def delete(options={})
-      options.merge!(:basic_auth => Client.credentials)
-      self.class.delete("#{Client.base_uri}/templates/#{template.id}/template_records/#{id}.json", options)
-    end
-    alias :destroy :delete
-
-    def self.create(short_name, name, record_type, content, options={})
-      template = Template.find(short_name)
+  def delete(options={})
+    DNSimple::Client.delete("templates/#{template.id}/template_records/#{id}.json", options)
+  end
+  alias :destroy :delete
 
-      record_hash = {:name => name, :record_type => record_type, :content => content}
-      record_hash[:ttl] = options.delete(:ttl) || 3600
-      record_hash[:prio] = options.delete(:prio) || ''
+  def self.create(short_name, name, record_type, content, options={})
+    template = DNSimple::Template.find(short_name)
 
-      options.merge!({:query => {:dns_template_record => record_hash}})
-      options.merge!({:basic_auth => Client.credentials})
+    record_hash = {:name => name, :record_type => record_type, :content => content}
+    record_hash[:ttl] = options.delete(:ttl) || 3600
+    record_hash[:prio] = options.delete(:prio) || ''
 
-      response = self.post("#{Client.base_uri}/templates/#{template.id}/template_records.json", options)
+    options.merge!({:query => {:dns_template_record => record_hash}})
 
-      pp response if Client.debug?
+    response = DNSimple::Client.post("templates/#{template.id}/template_records.json", options)
 
-      case response.code
-      when 201
-        return TemplateRecord.new({:template => template}.merge(response["dns_template_record"]))
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise DNSimple::Error.new("#{name}", response["errors"])
-      end
+    case response.code
+    when 201
+      return new({:template => template}.merge(response["dns_template_record"]))
+    else
+      raise DNSimple::Error.new("#{name}", response["errors"])
     end
+  end
 
-    def self.find(short_name, id, options={})
-      template = Template.find(short_name)
-      options.merge!(:basic_auth => Client.credentials)
-      response = self.get("#{Client.base_uri}/templates/#{template.id}/template_records/#{id}.json", options)
-
-      pp response if Client.debug?
-
-      case response.code
-      when 200
-        return TemplateRecord.new({:template => template}.merge(response["dns_template_record"]))
-      when 401
-        raise RuntimeError, "Authentication failed"
-      when 404
-        raise RuntimeError, "Could not find template record #{id} for template #{short_name}"
-      end
-    end
+  def self.find(short_name, id, options={})
+    template = DNSimple::Template.find(short_name)
+    response = DNSimple::Client.get("templates/#{template.id}/template_records/#{id}.json", options)
 
-    # Get all of the template records for the template with the
-    # given short name.
-    def self.all(short_name, options={})
-      template = Template.find(short_name)
-      options.merge!({:basic_auth => Client.credentials})
-      response = self.get("#{Client.base_uri}/templates/#{template.id}/template_records.json", options)
-
-      pp response if Client.debug?
-
-      case response.code
-      when 200
-        response.map { |r| TemplateRecord.new({:template => template}.merge(r["dns_template_record"])) }
-      when 401
-        raise RuntimeError, "Authentication failed"
-      else
-        raise RuntimeError, "Error: #{response.code}"
-      end
+    case response.code
+    when 200
+      return new({:template => template}.merge(response["dns_template_record"]))
+    when 404
+      raise RuntimeError, "Could not find template record #{id} for template #{short_name}"
     end
   end
 
-
+  # Get all of the template records for the template with the
+  # given short name.
+  def self.all(short_name, options={})
+    template = DNSimple::Template.find(short_name)
+    response = DNSimple::Client.get("templates/#{template.id}/template_records.json", options)
+
+    case response.code
+    when 200
+      response.map { |r| new({:template => template}.merge(r["dns_template_record"])) }
+    else
+      raise RuntimeError, "Error: #{response.code}"
+    end
+  end
 end