dnsimple-ruby 1.7.1 → 2.0.0

data/lib/dnsimple/commands/record_describe.rb

@@ -1,16 +0,0 @@
-module DNSimple
-  module Commands
-    class RecordDescribe
-      def execute(args, options = {})
-        name = args.shift
-        id = args.shift
-        record = Record.find(name, id)
-        puts "Record #{record.fqdn}:"
-        puts "\tID: #{record.id}"
-        puts "\tTTL: #{record.ttl}"
-        puts "\tPrio: #{record.prio}"
-        puts "\tContent: #{record.content}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/record_list.rb

@@ -1,19 +0,0 @@
-module DNSimple
-  module Commands
-    class RecordList
-      def execute(args, options = {})
-        domain_name = args.shift
-
-        records = Record.all(DNSimple::Domain.new(:name => domain_name))
-
-        puts "Found #{records.length} records for #{domain_name}"
-        records.each do |record|
-          extra = ["ttl:#{record.ttl}", "id:#{record.id}"]
-          extra << "prio:#{record.prio}" if record.record_type == "MX"
-          extra = "(#{extra.join(', ')})"
-          puts "\t#{record.name}.#{record.domain.name} (#{record.record_type})-> #{record.content} #{extra}"
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/record_update.rb

@@ -1,23 +0,0 @@
-module DNSimple
-  module Commands
-    class RecordUpdate
-      def execute(args, options = {})
-        attributes = {}
-        domain_name = args.shift
-        id = args.shift
-        args.each do |arg|
-          name, value = arg.split(":")
-          attributes[Record.resolve(name)] = value
-        end
-
-        domain = Domain.find(domain_name)
-        record = Record.find(domain, id)
-        attributes.each do |name, value|
-          record.send("#{name}=", value)
-        end
-        record.save
-        puts "Updated record #{record.fqdn} (id: #{record.id})"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_add.rb

@@ -1,14 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceAdd
-      def execute(args, options = {})
-        domain_name = args.shift
-        domain = Domain.find(domain_name)
-        short_name = args.shift
-        service = Service.find(short_name)
-        domain.add_service(short_name)
-        puts "Added #{service.name} to #{domain_name}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_describe.rb

@@ -1,12 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceDescribe
-      def execute(args, options = {})
-        short_name = args.shift
-        service = Service.find(short_name)
-        puts "\t#{service.name} (short: #{service.short_name}, id: #{service.id})"
-        puts "\t\t#{service.description}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_list.rb

@@ -1,14 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceList
-      def execute(args, options = {})
-        services = Service.all
-        puts "Found #{services.length} services:"
-        services.each do |service|
-          puts "\t#{service.name} (short: #{service.short_name}, id: #{service.id})"
-          puts "\t\t#{service.description}"
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_list_applied.rb

@@ -1,16 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceListApplied
-      def execute(args, options = {})
-        domain_name = args.shift
-        domain = Domain.find(domain_name)
-        services = domain.applied_services
-        puts "Found #{services.length} applied services for #{domain_name}"
-        services.each do |service|
-          puts "\t#{service.name} (short: #{service.short_name}, id: #{service.id})"
-          puts "\t\t#{service.description}"
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_list_available.rb

@@ -1,16 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceListAvailable
-      def execute(args, options = {})
-        domain_name = args.shift
-        domain = Domain.find(domain_name)
-        services = domain.available_services
-        puts "Found #{services.length} available services for #{domain_name}"
-        services.each do |service|
-          puts "\t#{service.name} (short: #{service.short_name}, id: #{service.id})"
-          puts "\t\t#{service.description}"
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/service_remove.rb

@@ -1,14 +0,0 @@
-module DNSimple
-  module Commands
-    class ServiceRemove
-      def execute(args, options = {})
-        domain_name = args.shift
-        domain = Domain.find(domain_name)
-        short_name = args.shift
-        service = Service.find(short_name)
-        domain.remove_service(service.id)
-        puts "Removed #{service.name} from #{domain_name}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_create.rb

@@ -1,14 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateCreate
-      def execute(args, options = {})
-        name = args.shift
-        short_name = args.shift
-        description = args.shift unless args.empty?
-
-        template = Template.create(name, short_name, description)
-        puts "Created #{template.name} (short_name:#{template.short_name})"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_delete.rb

@@ -1,13 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateDelete
-      def execute(args, options = {})
-        short_name = args.shift
-        template = Template.find(short_name)
-        template.delete
-
-        puts "Deleted template #{short_name}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_list.rb

@@ -1,13 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateList
-      def execute(args, options = {})
-        templates = Template.all
-        puts "Found #{templates.length} templates:"
-        templates.each do |template|
-          puts "\t#{template.name} (short_name:#{template.short_name})" 
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_record_create.rb

@@ -1,18 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateRecordCreate
-      def execute(args, options = {})
-        short_name = args.shift
-        record_name = args.shift
-        record_type = args.shift
-        content = args.shift
-        ttl = args.shift
-
-        template = Template.find(short_name)
-        record = TemplateRecord.create(template.short_name, record_name, record_type, content, :ttl => ttl, :prio => options[:prio])
-        
-        puts "Created #{record.record_type} with content '#{record.content}' record for template #{template.name}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_record_delete.rb

@@ -1,16 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateRecordDelete
-      def execute(args, options = {})
-        short_name = args.shift
-        id = args.shift
-
-        template = Template.find(short_name)
-        record = TemplateRecord.find(template.short_name, id)
-        record.delete
-
-        puts "Deleted #{record.id} from template #{short_name}"
-      end
-    end
-  end
-end

data/lib/dnsimple/commands/template_record_list.rb

@@ -1,17 +0,0 @@
-module DNSimple
-  module Commands
-    class TemplateRecordList
-      def execute(args, options = {})
-        short_name = args.shift
-        template_records = TemplateRecord.all(short_name)
-        puts "Found #{template_records.length} records for #{short_name}"
-        template_records.each do |record|
-          extra = ["ttl:#{record.ttl}", "id:#{record.id}"]
-          extra << "prio:#{record.prio}" if record.record_type == "MX"
-          extra = "(#{extra.join(', ')})"
-          puts "\t#{record.name} (#{record.record_type})-> #{record.content} #{extra}"
-        end
-      end
-    end
-  end
-end

data/lib/dnsimple/contact.rb

@@ -1,154 +0,0 @@
-module DNSimple
-
-  # Represents a contact.
-  class Contact < Base
-
-    Aliases = {
-      'first'             => 'first_name',
-      'last'              => 'last_name',
-      'state'             => 'state_province',
-      'province'          => 'state_province',
-      'state_or_province' => 'state_province',
-      'email'             => 'email_address',
-    }
-
-    # The contact ID in DNSimple
-    attr_accessor :id
-
-    # The contact first name
-    attr_accessor :first_name
-
-    # The contact last name
-    attr_accessor :last_name
-
-    # The contact's job title
-    attr_accessor :job_title
-
-    # The name of the organization in which the contact works
-    attr_accessor :organization_name
-
-    # The contact email address
-    attr_accessor :email_address
-
-    # The contact phone number
-    attr_accessor :phone
-
-    # The contact phone extension (may be omitted)
-    attr_accessor :phone_ext
-
-    # The contact fax number (may be omitted)
-    attr_accessor :fax
-
-    # The contact street address
-    attr_accessor :address1
-
-    # Apartment or suite number
-    attr_accessor :address2
-
-    # The city name
-    attr_accessor :city
-
-    # The state or province name
-    attr_accessor :state_province
-
-    # The contact postal code
-    attr_accessor :postal_code
-
-    # The contact country (as a 2-character country code)
-    attr_accessor :country
-
-    # When the contact was created in DNSimple
-    attr_accessor :created_at
-
-    # When the contact was last updated in DNSimple
-    attr_accessor :updated_at
-
-
-    # Map an aliased field name to it's real name. For example, if you
-    # pass "first" it will be resolved to "first_name", "email" is resolved
-    # to "email_address" and so on.
-    def self.resolve(name)
-      DNSimple::Contact::Aliases[name.to_s] || name
-    end
-
-    def self.resolve_attributes(attributes)
-      resolved_attributes = {}
-      attributes.each do |k, v|
-        resolved_attributes[resolve(k)] = v
-      end
-      resolved_attributes
-    end
-
-    # Create the contact with the given attributes in DNSimple.
-    # This method returns a Contact instance of the contact is created
-    # and raises an error otherwise.
-    def self.create(attributes, options={})
-      contact_hash = resolve_attributes(attributes)
-
-      options.merge!({:body => {:contact => contact_hash}})
-      response = DNSimple::Client.post("/v1/contacts", options)
-
-      case response.code
-      when 201
-        new(response["contact"])
-      else
-        raise RequestError.new("Error creating contact", response)
-      end
-    end
-
-    def self.find(id, options={})
-      response = DNSimple::Client.get("/v1/contacts/#{id}", options)
-
-      case response.code
-      when 200
-        new(response["contact"])
-      when 404
-        raise RecordNotFound, "Could not find contact #{id}"
-      else
-        raise RequestError.new("Error finding contact", response)
-      end
-    end
-
-    def self.all(options={})
-      response = DNSimple::Client.get("/v1/contacts", options)
-
-      case response.code
-      when 200
-        response.map { |r| new(r["contact"]) }
-      else
-        raise RequestError.new("Error listing contacts", response)
-      end
-    end
-
-
-    def name
-      [first_name, last_name].join(' ')
-    end
-
-    def save(options={})
-      contact_hash = {}
-      %w(first_name last_name organization_name job_title address1 address2 city
-      state_province postal_code country email_address phone phone_ext fax).each do |attribute|
-        contact_hash[DNSimple::Contact.resolve(attribute)] = self.send(attribute)
-      end
-
-      options.merge!({:body => {:contact => contact_hash}})
-
-      response = DNSimple::Client.put("/v1/contacts/#{id}", options)
-
-      case response.code
-        when 200
-          return self
-        else
-          raise RequestError.new("Error updating contact", response)
-      end
-    end
-
-    # Delete the contact from DNSimple. WARNING: this cannot be undone.
-    def delete(options={})
-      DNSimple::Client.delete("/v1/contacts/#{id}", options)
-    end
-    alias :destroy :delete
-
-  end
-end

data/lib/dnsimple/domain.rb

@@ -1,217 +0,0 @@
-module DNSimple
-  class Domain < Base
-
-    # 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
-
-    # When the domain is due to expire
-    attr_accessor :expires_on
-
-    # The state of the domain in DNSimple
-    attr_accessor :state
-
-    # ID of the registrant in DNSimple
-    attr_accessor :registrant_id
-
-    # User ID in DNSimple
-    attr_accessor :user_id
-    
-    # Is the domain lockable
-    attr_accessor :lockable
-    
-    # Is the domain set to autorenew
-    attr_accessor :auto_renew
-    
-    # Is the whois information protected
-    attr_accessor :whois_protected
-
-
-    # Check the availability of a name
-    def self.check(name, options={})
-      response = DNSimple::Client.get("/v1/domains/#{name}/check", options)
-
-      case response.code
-      when 200
-        "registered"
-      when 404
-        "available"
-      else
-        raise RequestError.new("Error checking availability", response)
-      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!({:body => {:domain => {:name => name}}})
-
-      response = DNSimple::Client.post("/v1/domains", options)
-
-      case response.code
-      when 201
-        new(response["domain"])
-      else
-        raise RequestError.new("Error creating domain", response)
-      end
-    end
-
-    # 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
-          body.merge!(:contact => DNSimple::Contact.resolve_attributes(registrant))
-        end
-      end
-      body.merge!(:extended_attribute => extended_attributes)
-      options.merge!({:body => body})
-
-      response = DNSimple::Client.post("/v1/domain_registrations", options)
-
-      case response.code
-      when 201
-        return DNSimple::Domain.new(response["domain"])
-      else
-        raise RequestError.new("Error registering domain", response)
-      end
-    end
-
-    # Find a specific domain in the account either by the numeric ID
-    # or by the fully-qualified domain name.
-    def self.find(id, options={})
-      response = DNSimple::Client.get("/v1/domains/#{id}", options)
-
-      case response.code
-      when 200
-        new(response["domain"])
-      when 404
-        raise RecordNotFound, "Could not find domain #{id}"
-      else
-        raise RequestError.new("Error finding domain", response)
-      end
-    end
-
-    # Get all domains for the account.
-    def self.all(options={})
-      response = DNSimple::Client.get("/v1/domains", options)
-
-      case response.code
-      when 200
-        response.map { |r| new(r["domain"]) }
-      else
-        raise RequestError.new("Error listing domains", response)
-      end
-    end
-
-    # Enable auto_renew on the domain
-    def enable_auto_renew
-      return if auto_renew
-      auto_renew!(:post)
-    end
-
-    # Disable auto_renew on the domain
-    def disable_auto_renew
-      return unless auto_renew
-      auto_renew!(:delete)
-    end
-
-    # Delete the domain from DNSimple. WARNING: this cannot
-    # be undone.
-    def delete(options={})
-      DNSimple::Client.delete("/v1/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("/v1/domains/#{name}/templates/#{template.id}/apply", options)
-    end
-
-    def resolve_template(template)
-      case template
-      when DNSimple::Template
-        template
-      else
-        DNSimple::Template.find(template)
-      end
-    end
-
-    def applied_services(options={})
-      response = DNSimple::Client.get("/v1/domains/#{name}/applied_services", options)
-
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Service.new(r["service"]) }
-      else
-        raise RequestError.new("Error listing applied services", response)
-      end
-    end
-
-    def available_services(options={})
-      response = DNSimple::Client.get("/v1/domains/#{name}/available_services", options)
-
-      case response.code
-      when 200
-        response.map { |r| DNSimple::Service.new(r["service"]) }
-      else
-        raise RequestError.new("Error listing available services", response)
-      end
-    end
-
-    def add_service(id_or_short_name, options={})
-      options.merge!(:body => {:service => {:id => id_or_short_name}})
-      response = DNSimple::Client.post("/v1/domains/#{name}/applied_services", options)
-
-      case response.code
-      when 200
-        true
-      else
-        raise RequestError.new("Error adding service", response)
-      end
-    end
-
-    def remove_service(id, options={})
-      response = DNSimple::Client.delete("/v1/domains/#{name}/applied_services/#{id}", options)
-
-      case response.code
-      when 200
-        true
-      else
-        raise RequestError.new("Error removing service", response)
-      end
-    end
-
-
-    private
-
-    def auto_renew!(method)
-      response = DNSimple::Client.send(method, "/v1/domains/#{name}/auto_renewal")
-      case response.code
-      when 200
-        self.auto_renew = response['domain']['auto_renew']
-      else
-        raise RequestError.new("Error setting auto_renew", response)
-      end
-    end
-
-  end
-end