dnsimple 2.0.0.alpha2 → 2.0.0.alpha3

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 << ExtendedAttribute::Option.new(opt)
-      end
-    end
-
-    # Find the extended attributes for the given TLD
-    def self.find(tld, options={})
-      response = 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 !~ BLANK_REGEX }.join(".")
-    end
-
-    def save(options={})
-      record_hash = {}
-      %w(name content ttl prio).each do |attribute|
-        record_hash[Record.resolve(attribute)] = self.send(attribute)
-      end
-
-      options.merge!(:body => {:record => record_hash})
-
-      response = 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={})
-      Client.delete("/v1/domains/#{domain.id}/records/#{id}", options)
-    end
-    alias :destroy :delete
-
-    def self.resolve(name)
-      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 = 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 = 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 = 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 = 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 = 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,65 +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 = 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 = 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 = 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={})
-      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={})
-      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 = 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 = 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 = Template.find(short_name)
-      response = 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 = Template.find(short_name)
-      response = 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 = 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,50 +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
-
-
-    # Fetches the information about the authenticated user.
-    #
-    # @return [User] the authenticated user
-    # @raise  [RequestError] if the user doesn't exist
-    def self.me
-      response = 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 = Client.get("/v1/user", :headers => { Client::HEADER_2FA_STRICT => "1", Client::HEADER_OTP_TOKEN => otp_token })
-      response.headers[Client::HEADER_EXCHANGE_TOKEN]
-    end
-
-  end
-end

data/spec/dnsimple/certificate_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Dnsimple::Certificate do
-
-  let(:domain) { Dnsimple::Domain.new(:name => "example.com") }
-
-
-  describe ".find" do
-    before do
-      stub_request(:get, %r[/v1/domains/example.com/certificates/2]).
-          to_return(read_fixture("certificates/show/success.http"))
-    end
-
-    it "builds the correct request" do
-      described_class.find(domain, "2")
-
-      expect(WebMock).to have_requested(:get, "https://#{CONFIG['username']}:#{CONFIG['password']}@#{CONFIG['host']}/v1/domains/example.com/certificates/2").
-          with(:headers => { 'Accept' => 'application/json' })
-    end
-
-    context "when the certificate exists" do
-      it "returns the certificate" do
-        result = described_class.find(domain, "2")
-
-        expect(result.id).to eq(4576)
-        expect(result.domain_id).to eq(79569)
-        expect(result.contact_id).to eq(11549)
-        expect(result.name).to eq("www")
-        expect(result.state).to eq("cancelled")
-        expect(result.csr).to eq("-----BEGIN NEW CERTIFICATE REQUEST-----\nRHr2akB4KMba6FMAsvlStnO/2ika16hNx+d3smPNsER+HA==\n-----END NEW CERTIFICATE REQUEST-----\n")
-        expect(result.ssl_certificate).to eq("-----BEGIN CERTIFICATE-----\nXwTkw5UCPpaVyUYcwHlvaprOe9ZbwIyEHm2AT1rW+70=\n-----END CERTIFICATE-----\n")
-        expect(result.private_key).to eq("-----BEGIN RSA PRIVATE KEY-----\nUeXbFi7o+nuPfRhpBFQEKwacKFc3Hnc1hH6UsnC0KY25cUif7yz38A==\n-----END RSA PRIVATE KEY-----\n")
-        expect(result.approver_email).to eq("example@example.net")
-        expect(result.created_at).to eq("2013-09-17T21:54:42Z")
-        expect(result.updated_at).to eq("2013-09-17T22:25:36Z")
-        expect(result.configured_at).to eq("2013-09-17T22:25:01Z")
-        expect(result.expires_on).to eq("2014-09-17")
-
-        expect(result.domain).to eq(domain)
-      end
-    end
-  end
-
-
-  describe "#fqdn" do
-    it "joins the name and domain name" do
-      certificate = described_class.new(:name => 'www')
-      certificate.domain = domain
-      expect(certificate.fqdn).to eq("www.#{domain.name}")
-    end
-
-    it "strips blank parts from name" do
-      certificate = described_class.new(:name => '')
-      certificate.domain = domain
-      expect(certificate.fqdn).to eq(domain.name)
-    end
-  end
-
-end