dnsimple-ruby 1.7.1 → 2.0.0

data/lib/dnsimple/error.rb

@@ -1,32 +0,0 @@
-module DNSimple
-
-  class Error < StandardError
-  end
-
-  class RecordExists < Error
-  end
-
-  class RecordNotFound < Error
-  end
-
-  # An exception that is raised if a method is called with missing or invalid parameter values.
-  class ValidationError < Error
-  end
-
-  class RequestError < Error
-    def initialize(description, response)
-      super("#{description}: #{response["error"]}")
-    end
-  end
-
-  class AuthenticationError < Error
-  end
-
-  class AuthenticationFailed < AuthenticationError
-  end
-
-  # An exception that is raised if a request is executed for an account that requires two-factor authentication.
-  class TwoFactorAuthenticationRequired < AuthenticationError
-  end
-
-end

data/lib/dnsimple/extended_attribute.rb

@@ -1,52 +0,0 @@
-module DNSimple
-
-  # Used for domains that require extended attributes.
-  class ExtendedAttribute < Base
-
-    # An option for an extended attribute
-    class Option < Base
-      # The option name
-      attr_accessor :title
-
-      # The option value
-      attr_accessor :value
-
-      # A long description of the option
-      attr_accessor :description
-    end
-
-    # The extended attribute name
-    attr_accessor :name
-
-    # A description of the extended attribute
-    attr_accessor :description
-
-    # Boolean indicating if the extended attribute is required
-    attr_accessor :required
-
-    # An array of options for the extended attribute
-    def options
-      @options ||= []
-    end
-
-    def options=(opts)
-      @options = []
-      opts.each do |opt|
-        @options << DNSimple::ExtendedAttribute::Option.new(opt)
-      end
-    end
-
-    # Find the extended attributes for the given TLD
-    def self.find(tld, options={})
-      response = DNSimple::Client.get("/v1/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,94 +0,0 @@
-module DNSimple
-
-  class Record < Base
-    Aliases = {
-      'priority'     => 'prio',
-      'time-to-live' => 'ttl'
-    }
-
-    attr_accessor :id
-    attr_accessor :domain
-    attr_accessor :name
-    attr_accessor :content
-    attr_accessor :ttl
-    attr_accessor :prio
-    attr_accessor :record_type
-
-
-    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
-
-      options.merge!(:body => {:record => record_hash})
-
-      response = DNSimple::Client.put("/v1/domains/#{domain.id}/records/#{id}", options)
-
-      case response.code
-      when 200
-        self
-      else
-        raise RequestError.new("Error updating record", response)
-      end
-    end
-
-    def delete(options={})
-      DNSimple::Client.delete("/v1/domains/#{domain.id}/records/#{id}", options)
-    end
-    alias :destroy :delete
-
-    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) || ''
-
-      options.merge!({:body => {:record => record_hash}})
-
-      response = DNSimple::Client.post("/v1/domains/#{domain.name}/records", options)
-
-      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
-
-    def self.find(domain, id, options={})
-      response = DNSimple::Client.get("/v1/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
-
-    def self.all(domain, options={})
-      response = DNSimple::Client.get("/v1/domains/#{domain.name}/records", options)
-
-      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,42 +0,0 @@
-module DNSimple
-
-  # Represents a service that can be applied to a domain.
-  class Service < Base
-
-    attr_accessor :id
-
-    attr_accessor :name
-
-    attr_accessor :short_name
-
-    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("/v1/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
-
-    # Get all of the services that can be applied to a domain
-    def self.all(options={})
-      response = DNSimple::Client.get("/v1/services", options)
-
-      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 +0,0 @@
-module DNSimple
-  class Template < Base
-
-    attr_accessor :id
-    attr_accessor :name
-    attr_accessor :short_name
-    attr_accessor :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})
-
-      response = DNSimple::Client.post("/v1/templates", options)
-
-      case response.code
-      when 201
-        new(response["dns_template"])
-      else
-        raise RequestError.new("Error creating template", response)
-      end
-    end
-
-    def self.find(id_or_short_name, options={})
-      id = id_or_short_name
-      response = DNSimple::Client.get("/v1/templates/#{id}", options)
-
-      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
-
-    def self.all(options={})
-      response = DNSimple::Client.get("/v1/templates", options)
-
-      case response.code
-      when 200
-        response.map { |r| new(r["dns_template"]) }
-      else
-        raise RequestError.new("Error listing templates", response)
-      end
-    end
-
-
-    # Delete the template from DNSimple.
-    # WARNING: this cannot be undone.
-    def delete(options={})
-      DNSimple::Client.delete("/v1/templates/#{id}", options)
-    end
-    alias :destroy :delete
-
-  end
-end

data/lib/dnsimple/template_record.rb

@@ -1,80 +0,0 @@
-module DNSimple
-
-  # A single record in a template.
-  class TemplateRecord < Base
-
-    # The id of the template record
-    attr_accessor :id
-
-    # The template the record belongs to
-    attr_accessor :template
-
-    # The name the record points to. This may be blank.
-    attr_accessor :name
-
-    # The content for the record.
-    attr_accessor :content
-
-    # The record type
-    attr_accessor :record_type
-
-    # The time-to-live
-    attr_accessor :ttl
-
-    # The priority (only for MX records)
-    attr_accessor :prio
-
-    def delete(options={})
-      DNSimple::Client.delete("/v1/templates/#{template.id}/template_records/#{id}", options)
-    end
-    alias :destroy :delete
-
-    def self.create(short_name, name, record_type, content, options={})
-      template = DNSimple::Template.find(short_name)
-
-      record_hash = {:name => name, :record_type => record_type, :content => content}
-      record_hash[:ttl] = options.delete(:ttl) || 3600
-      record_hash[:prio] = options.delete(:prio) || ''
-
-      options.merge!({:query => {:dns_template_record => record_hash}})
-
-      response = DNSimple::Client.post("/v1/templates/#{template.id}/template_records", options)
-
-      case response.code
-      when 201
-        new({:template => template}.merge(response["dns_template_record"]))
-      else
-        raise RequestError.new("Error creating template record", response)
-      end
-    end
-
-    def self.find(short_name, id, options={})
-      template = DNSimple::Template.find(short_name)
-      response = DNSimple::Client.get("/v1/templates/#{template.id}/template_records/#{id}", options)
-
-      case response.code
-      when 200
-        new({:template => template}.merge(response["dns_template_record"]))
-      when 404
-        raise RecordNotFound, "Could not find template record #{id} for template #{template.id}"
-      else
-        raise RequestError.new("Error finding template record", response)
-      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("/v1/templates/#{template.id}/template_records", options)
-
-      case response.code
-      when 200
-        response.map { |r| new({:template => template}.merge(r["dns_template_record"])) }
-      else
-        raise RequestError.new("Error listing template records", response)
-      end
-    end
-
-  end
-end

data/lib/dnsimple/transfer_order.rb

@@ -1,34 +0,0 @@
-module DNSimple
-
-  # Represents a transfer order.
-  class TransferOrder < Base
-
-    attr_accessor :id
-
-    attr_accessor :status
-
-    def self.create(name, authinfo='', registrant={}, extended_attributes={}, options={})
-      body = {:domain => {:name => name}, :transfer_order => {:authinfo => authinfo}}
-
-      if registrant[:id]
-        body[:domain][:registrant_id] = registrant[:id]
-      else
-        body.merge!(:contact => Contact.resolve_attributes(registrant))
-      end
-
-      body.merge!(:extended_attribute => extended_attributes)
-
-      options.merge!({:body => body})
-
-      response = DNSimple::Client.post("/v1/domain_transfers", options)
-
-      case response.code
-      when 201
-        new(response["transfer_order"])
-      else
-        raise RequestError.new("Error creating transfer order", response)
-      end
-    end
-
-  end
-end

data/lib/dnsimple/user.rb

@@ -1,51 +0,0 @@
-module DNSimple
-  class User < Base
-
-    attr_accessor :id
-    attr_accessor :email
-    attr_accessor :domain_count
-    attr_accessor :domain_limit
-    attr_accessor :login_count
-    attr_accessor :failed_login_count
-    attr_accessor :created_at
-    attr_accessor :updated_at
-
-
-    # Gets the information about the authenticated user.
-    #
-    # @return [User] the authenticated user
-    # @raise  [RequestError] if the user doesn't exist
-    def self.me
-      response = DNSimple::Client.get("/v1/user")
-
-      case response.code
-      when 200
-        new(response["user"])
-      else
-        raise RequestError.new("Error finding account", response)
-      end
-    end
-
-    # Requests a new two-factor authentication exchange token.
-    #
-    # The exchange-token is required to validate API requests
-    # using HTTP Basic Authentication when the account has two-factor authentication enabled.
-    #
-    # @see http://developer.dnsimple.com/authentication/#twofa
-    #
-    # @example Request an Exchange Token
-    #
-    #   DNSimple::User.two_factor_exchange_token('0000000')
-    #   # => "cda038832591e34f5df642ce2b61dc78"
-    #
-    # @param  [String] otp_token the two-factor one time (OTP) token
-    #
-    # @return [String] the two-factor API exchange token
-    # @raise  [AuthenticationFailed] if the provided OTP token is invalid
-    def self.two_factor_exchange_token(otp_token)
-      response = DNSimple::Client.get("/v1/user", :headers => { DNSimple::Client::HEADER_2FA_STRICT => "1", DNSimple::Client::HEADER_OTP_TOKEN => otp_token })
-      response.headers[DNSimple::Client::HEADER_EXCHANGE_TOKEN]
-    end
-
-  end
-end