zerigodns 1.0.2 → 1.1.0

data/lib/zerigodns.rb

@@ -1,7 +1,19 @@
 # Copyright 2009 Zerigo, Inc.  See MIT-LICENSE for license information.
 # Visit http://www.zerigo.com/docs/managed-dns for updates and documentation.
-require 'activeresource-ext'
-require 'zerigodns/base'
+require 'faraday'
+require 'multi_xml'
+require 'zerigodns/client'
+require 'zerigodns/client/response_code'
+
+require 'zerigodns/middleware'
+require 'zerigodns/middleware/xml'
+require 'zerigodns/middleware/error_handler'
+require 'zerigodns/middleware/zerigo_auth'
+
+require 'zerigodns/resource'
+require 'zerigodns/resource/rest'
+require 'zerigodns/resource/naming'
+require 'zerigodns/resource/attributes'
 require 'zerigodns/config'
 require 'zerigodns/host'
 require 'zerigodns/zone'

data/lib/zerigodns/client.rb

@@ -0,0 +1,67 @@
+module ZerigoDNS
+  class Client
+    
+    #@!attribute response [r]
+    # @return [Faraday::Response] exposes the response.
+    ResponseError = Class.new(RuntimeError) do 
+      attr_reader :response
+      
+      # Initialize a new ResponseError with a response.
+      def initialize response=nil
+        @response=response
+      end
+      
+      # Convert to a string
+      # @return [String] The error's message.
+      def to_s
+        inspect
+      end
+      
+      # @return [String] The error's message
+      def message
+        inspect
+      end
+      
+      # @return [String] The error's message
+      def inspect
+        "HTTP Response Error: #{response && response.status}"
+      end
+    end
+    
+    # Standard REST Actions
+    ACTIONS = %w(get post put patch delete)
+    
+    ACTIONS.each do |action|
+      define_method action do |*args|
+        self.class.send(action, *args)
+      end
+    end
+    
+    
+    class <<self
+      # Gets or creates a new faraday connection.
+      def connection
+        
+        # => Note:  Order matters here!
+        @connection ||= Faraday.new(
+          url: ZerigoDNS.config.site, 
+        ) do |faraday|
+          faraday.request :zerigo_auth
+          faraday.request :multipart
+          faraday.request :url_encoded
+          
+          faraday.adapter Faraday.default_adapter
+          
+          faraday.response :custom_xml
+          faraday.response :custom_error_handler
+        end
+      end
+      
+      ACTIONS.each do |action|
+        define_method action do |*args|
+          connection.send action, *args
+        end
+      end
+    end
+  end
+end

data/lib/zerigodns/client/response_code.rb

@@ -0,0 +1,29 @@
+# Represents a response code and allows more expressive querying of response status.
+# e.g. +response.env[:code].ok?+ as opposed to +(200..299).include?(response.status)+
+class ZerigoDNS::Client::ResponseCode
+  attr_reader :raw_code
+  
+  def initialize raw_code
+    @raw_code = raw_code
+  end
+  
+  # @return [Boolean] true if the response was OK
+  def ok?
+    (200..299).include?(raw_code) || raw_code == 302
+  end
+  
+  # @return [Boolean] true if the response was not OK
+  def error?
+    !ok?
+  end
+  
+  # @return [Boolean] true if response is 500 internal server error.
+  def server_error?
+    raw_code == 500
+  end
+  
+  # @return [Boolean] true if response is 404
+  def not_found?
+    raw_code == 404
+  end
+end

data/lib/zerigodns/config.rb

@@ -3,16 +3,31 @@ module ZerigoDNS
   #@attr [String] user Your e-mail address
   #@attr [Boolean] secure Whether to use HTTPS
   class Config
+    attr_accessor :api_key, :user, :secure, :site
     
-    BASE_ATTRIBUTES = %w(api_key site secure user password)
-      BASE_ATTRIBUTES.each do |attr|
-        define_method attr do
-          ZerigoDNS::Base.send(attr)
-        end
-        
-        define_method "#{attr}=" do |val|
-          ZerigoDNS::Base.send("#{attr}=", val)
-        end
+    def initialize
+      @site = 'https://ns.zerigo.com/api/1.1'
+    end
+    
+    # @return [Boolean] +true+ if +https+ is used
+    def secure?
+      !!secure
+    end
+    
+    
+    # Set +https+ or +http+
+    # @param [Boolean] value +true+ to use +https+, false for +http+
+    # Note: Will change the value of +site+!
+    def secure= value
+      @secure=value
+
+      if secure?
+        site = 'https://ns.zerigo.com/api/1.1'
+      else
+        site = 'http://ns.zerigo.com/api/1.1'
       end
+      
+      secure
+    end
   end
 end

data/lib/zerigodns/host.rb

@@ -1,23 +1,39 @@
-class ZerigoDNS::Host < ZerigoDNS::Base
+class ZerigoDNS::Host < ZerigoDNS::Client
+  include ZerigoDNS::Resource
+  
+  
   class << self
     
+    
     # Find host record(s) by zone and hostname
-    # @param [Symbol, #read] which One of :one, :first, :last, or :all.  See http://api.rubyonrails.org/v3.2.1/classes/ActiveResource/Base.html#method-c-find
+    # @param [Symbol, #read] which One of :one, :first, :last, or :all.
     # @param [Zone, #read] zone The zone from which to find the host record.
+    
     # @param [String, #read] hostname The hostname to find.
     # @return Host records, or an empty list if no records found.
     def find_by_zone_and_hostname which, zone, hostname
-      fqdn = [hostname, zone.domain].select(&:present?).join('.')
-      find(which, params: {fqdn: fqdn, zone_id: zone.id})
+      if which == :all
+        find_all_by_hostname(zone, hostname)
+      else
+        find_all_by_hostname(zone, hostname).send(which)
+      end
     end
     
+    
+    
+    
+    # Find host record(s) by zone and hostname
+    # @param [Zone, #read] zone The zone from which to find the host record.
+    # @param [String, #read] hostname The hostname to find.
+    # @return Host records, or an empty list if no records found.
     def find_all_by_hostname zone, hostname
-      find_by_zone_and_hostname(:all, zone, hostname)
+      fqdn = [hostname, zone.domain].reject(&:nil?).reject(&:empty?).join('.')
+      all(fqdn: fqdn, zone_id: zone.id)
     end
     
     # @return [Host] The record found, or nil.
     def find_first_by_hostname zone, hostname
-      find_by_zone_and_hostname(:all, zone, hostname).try(:first)
+      find_all_by_hostname(zone, hostname).first
     end
     
     # Update or Create Host for a zone
@@ -31,7 +47,7 @@ class ZerigoDNS::Host < ZerigoDNS::Base
     def update_or_create(zone, hostname, type, ttl, data)
       host = find_first_by_hostname(zone, hostname)
       if host
-        host.update_record(type,ttl,data)
+        host.update(ttl: ttl, host_type: type, data: data)
       else
         host = create(
           :zone_id    => zone.id, 
@@ -44,16 +60,4 @@ class ZerigoDNS::Host < ZerigoDNS::Base
       host
     end
   end
-  
-  # Convienence method to update the record.
-  # @param [String, #read] type
-  # @param [String, #read] ttl 
-  # @param [String, #read] data
-  # @return [Boolean, #read] True if saved, false otherwise.
-  def update_record type, ttl, data
-    self.host_type  = type
-    self.data       = data
-    self.ttl        = ttl
-    save
-  end
 end

data/lib/zerigodns/host_template.rb

@@ -1,4 +1,7 @@
-class ZerigoDNS::HostTemplate < ZerigoDNS::Base
+class ZerigoDNS::HostTemplate < ZerigoDNS::Client
+  
+  include ZerigoDNS::Resource
+  
   
   # Fetches the zone template to which the host template belongs.
   # @return [ZoneTemplate] The zone template to which the host template belongs.

data/lib/zerigodns/middleware.rb

@@ -0,0 +1,3 @@
+module ZerigoDNS::Middleware
+  
+end

data/lib/zerigodns/middleware/error_handler.rb

@@ -0,0 +1,22 @@
+# Rasies exceptions on errors
+class ZerigoDNS::Middleware::ErrorHandler < Faraday::Middleware
+  # Constructs new middleware instance
+  def initialize app=nil, options={}
+    @app = app
+    @options = options
+  end
+  
+  # Rasies an exception on a response code that is not HTTP OK
+  def call request_env
+    @app.call(request_env).on_complete do |response|
+      response[:code] = ZerigoDNS::Client::ResponseCode.new(response.status)
+      if response[:code].ok?
+        response
+      else
+        raise ZerigoDNS::Client::ResponseError.new(response)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware custom_error_handler: lambda {ZerigoDNS::Middleware::ErrorHandler}

data/lib/zerigodns/middleware/xml.rb

@@ -0,0 +1,29 @@
+# Simple XML parsing middleware for Faraday.
+# uses +multi_xml+.
+class ZerigoDNS::Middleware::Xml < Faraday::Middleware
+  
+  XML_REGEXP = /xml/
+  
+  
+  # Parse the XML, if XML exists.
+  # Note: This +must+ return the response in order for the stack of middleware to continue.
+  # @return [Faraday::Response] The response received
+  def call request_env
+    @app.call(request_env).on_complete do |response|
+      if xml?(response)
+        response[:raw_body] = response[:body]
+        response[:body] = MultiXml.parse(response[:body])
+      end
+      response
+    end
+  end
+  
+  
+  private
+  
+  def xml? env
+    !!XML_REGEXP.match(env[:response_headers]['Content-Type'])
+  end
+end
+
+Faraday::Response.register_middleware custom_xml: ZerigoDNS::Middleware::Xml

data/lib/zerigodns/middleware/zerigo_auth.rb

@@ -0,0 +1,26 @@
+# Handles authentication using the Zerigo config.
+class ZerigoDNS::Middleware::ZerigoAuth < Faraday::Middleware
+  # Constructs new middleware instance
+  def initialize app=nil, options={}
+    @app = app
+  end
+  
+  # Adds username & api key to Basic Auth header.
+  # @param [Faraday::Request] env The request
+  def call env
+    # => Ruby 1.8.7 does not support Base64.strict_encode64
+    auth_enc = Base64.encode64(formatted_login).gsub("\n", '')
+    env.request_headers['Authorization'] = "Basic #{auth_enc}"
+    @app.call(env)
+  end
+  
+  private
+  
+  # Gets the user:password format from ZerigoDNS.config
+  # @return [String] formatted login details
+  def formatted_login
+    [ZerigoDNS.config.user, ZerigoDNS.config.api_key].join(':')
+  end
+end
+
+Faraday::Request.register_middleware zerigo_auth: ZerigoDNS::Middleware::ZerigoAuth

data/lib/zerigodns/resource.rb

@@ -0,0 +1,38 @@
+# A lightweight resource class that will do much of the work of ActiveResource
+# without the big dependencies.
+
+module ZerigoDNS::Resource
+  module ClassMethods
+    # Removes the root from the response and hands it off to the class to process it
+    # Processes an array response by delegating to the includer's self.from_response
+    # @param [Faraday::Response] response The response
+    # @return [Object] The result of the parsed response.
+    def process_response response
+      without_root = response.body.values.first
+      case
+      when without_root.is_a?(Array) then process_array(response, without_root)
+      when without_root.is_a?(Hash) then from_response(response, without_root)
+      else without_root
+      end
+    end
+    
+    
+    # Processes an array response by delegating to the includer's self.from_response
+    # @param [Faraday::Response] response The response
+    # @param [Array] body The response body, with root removed
+    # @return [Array] The resultant array.
+    def process_array response, body
+      body.map do |element|
+        from_response response, element
+      end
+    end
+  end
+  
+  
+  def self.included includer
+    includer.send :include, Attributes
+    includer.send :include, Rest
+    includer.send :include, Naming
+    includer.send :extend, ClassMethods
+  end
+end

data/lib/zerigodns/resource/attributes.rb

@@ -0,0 +1,59 @@
+# Simple attribute handling for resources
+# Ties in with ZerigoDNS::Resource by defining a 
+# from_response method to initialize the class by its attributes. 
+module ZerigoDNS::Resource::Attributes
+  module InstanceMethods
+    attr_accessor :attributes
+    
+    
+    # Allows method-style access to the attributes.
+    def method_missing mtd, *args
+      if mtd.to_s.chars.to_a.last == '='
+        raise ArgumentError, "Invalid number of arguments (#{args.length} for 1)" if args.length != 1
+        attributes[mtd.to_s.slice(0,mtd.to_s.length-1)] = args.first
+      else
+        raise ArgumentError, "Invalid number of arguments (#{args.length} for 0)" if args.length != 0
+        attributes[mtd.to_s]
+      end
+    end
+    
+    # Converts the resource to a hash
+    # @return [Hash] The attributes
+    def to_hash
+      attributes
+    end
+    
+    # Initialize a new resource
+    # @param [Hash] attributes Initial attributes.
+    def initialize attributes={}
+      @attributes = {}
+      merge_attributes attributes
+    end
+    
+    private
+    
+    # Merge current attributes with specified ones.
+    # Will handle symbols as well as strings as keys
+    # @param [Hash] attrs Attributes to merge
+    def merge_attributes attrs
+      attrs.each do |key, val|
+        send("#{key}=", val)
+      end
+    end
+  end
+  
+  
+  module ClassMethods
+    # Constructs a new resource from a response
+    # @param [Faraday::Response] response The response
+    # @param [Hash] body The response body without root
+    def from_response response, body
+      new body
+    end
+  end
+  
+  def self.included includer
+    includer.send :include, InstanceMethods
+    includer.send :extend, ClassMethods
+  end
+end

data/lib/zerigodns/resource/naming.rb

@@ -0,0 +1,47 @@
+# Simple attribute handling for resources
+# Ties in with ZerigoDNS::Resource by defining a 
+# from_response method to initialize the class by its attributes. 
+module ZerigoDNS::Resource::Naming
+  
+  module ClassMethods
+    # Default Resource Name
+    # @return [String] generated resource name from class name "e.g. ZerigoDNS::ZoneTemplate -> zone_template"
+    def default_resource_name
+      result = self.to_s.split("::").last.gsub(/([A-Z])/, '_\1').downcase
+      result.slice 1, result.length
+    end
+    
+    
+    # Default base path.
+    # @return [String] Generated base path from class name (default_resource_name + "s")
+    def default_base_path
+      "#{resource_name}s"
+    end
+    
+    
+    # Sets & gets the "resource name", which is required for the create & update actions.
+    # @param [String] name resource name
+    # @return [String] the base path
+    def resource_name name=nil
+      if name
+        @resource_name = name
+      end
+      @resource_name || default_resource_name
+    end
+    
+    # Sets or gets the "base path", where the resource is located.
+    # @param [String] path base path
+    # @return [String] the base path
+    def base_path path=nil
+      if path
+        @base_path = path
+      end
+      @base_path || default_base_path
+    end
+  end
+  
+  
+  def self.included includer
+    includer.send :extend, ClassMethods
+  end
+end

data/lib/zerigodns/resource/rest.rb

@@ -0,0 +1,80 @@
+# Puts a basic resource abstraction over basic REST calls.
+module ZerigoDNS::Resource::Rest
+  module InstanceMethods
+    
+    # Update this instance's resource with attributes supplied into +params+
+    # @param [Hash] params The attributes to set
+    # @return [Object] The instance on which +update+ was called
+    def update params
+      self.class.update id, params
+      merge_attributes params
+      self
+    end
+    
+    # Destroy this instance's resource
+    # @param [Hash] params The attributes to set
+    # @raise [ZerigoDNS::Client::ResponseError] if delete does not succeed.
+    # @return [Faraday::Response] The response returned from the server.
+    def destroy params={}
+      self.class.destroy id, params
+    end
+  end
+  
+  module ClassMethods
+    
+    # Lists all resources
+    # @return [Array] The resources as an array
+    def all params={}
+      process_response get("#{base_path}.xml", params)
+    end
+    
+    # Find a single resource
+    # @param [Object] id_or_name The id or name of the resource to find
+    # @raise [ZerigoDNS::Client::ResponseError] if the find does not succeed.
+    # @return [Object] The requested resource.
+    def find id_or_name, params={}
+      process_response get("#{base_path}/#{id_or_name}.xml", params)
+    end
+    
+    # Updates a single resource
+    # @param [Object] id_or_name Id or name of the resource
+    # @raise [ZerigoDNS::Client::ResponseError] if update does not succeed.
+    # @return [Faraday::Response] The response returned by the server.
+    def update id_or_name, params={}
+      put "#{base_path}/#{id_or_name}.xml", convert(params)
+    end
+    
+    # Creates a resource
+    # @param [Object] params Parameters to pass to create action
+    # @raise [ZerigoDNS::Client::ResponseError] if create does not succeed.
+    # @return [Object] the created resource
+    def create params={}
+      process_response(post "#{base_path}.xml", convert(params))
+    end
+    
+    # Deletes a resource
+    # @param [Object] params Parameters to pass to delete action
+    # @raise [ZerigoDNS::Client::ResponseError] if destroy does not succeed.
+    def destroy id_or_name, params={}
+      delete "#{base_path}/#{id_or_name}.xml", params
+    end
+    
+    
+    private
+    
+    # Converts a resource object to a hash.
+    # @param [Object] object to convert to a hash
+    # @raise [ArgumentError] if the object given does not respond to to_hash
+    def convert object
+      return {resource_name => object} if object.is_a? Hash
+      {resource_name =>  object.to_hash}
+    end
+    
+  end
+  
+  def self.included includer
+    includer.send :include, InstanceMethods
+    includer.send :extend, ClassMethods
+  end
+end  
+

data/lib/zerigodns/tools.rb

@@ -1,22 +1,22 @@
-class ZerigoDNS::Tools < ZerigoDNS::Base
+class ZerigoDNS::Tools < ZerigoDNS::Client
   class <<self
     
     # Fetch current public ipv4 address
     # @return [String] Current public ipv4 address or "unknown"
     def public_ipv4
-      get :public_ipv4
+      get('tools/public_ipv4.xml').body['ipv4']
     end
     
     # Fetch current public ipv6 address
     # @return [String] Current public ipv6 address or "unknown"
     def public_ipv6
-      get :public_ipv6
+      get('tools/public_ipv6.xml').body['ipv6']
     end
     
     # Fetch the current public IP address (either ipv4 or ipv6)
     # @return [String] Current public ip address (ipv4 or ipv6)
     def public_ip
-      get :public_ip
+      get('tools/public_ip').body['ipv4'] || get('tools/public_ip').body['ipv6']
     end
   end
 

data/lib/zerigodns/zone.rb

@@ -1,9 +1,12 @@
-class ZerigoDNS::Zone < ZerigoDNS::Base
+class ZerigoDNS::Zone < ZerigoDNS::Client
+  include ZerigoDNS::Resource
+  
   class <<self
+    
     # Get count of all zones
     # @return [Fixnum] Count of all zones
     def count
-      get(:count).to_i
+      get('zones/count.xml').body['count'].to_i
     end
     
     # Find zone by domain name
@@ -19,7 +22,8 @@ class ZerigoDNS::Zone < ZerigoDNS::Base
     # @return [Zone] the zone found or created.
     def find_or_create(domain)
       find_by_domain(domain)
-    rescue ActiveResource::ResourceNotFound
+    rescue ZerigoDNS::Client::ResponseError => e
+      raise unless e.response.code.not_found?
       create(:domain=> domain, :ns_type=>'pri_sec')
     end
   end
@@ -27,6 +31,6 @@ class ZerigoDNS::Zone < ZerigoDNS::Base
   # Get count of all hosts belonging to this zone
   # @return [Fixnum] Count of all hosts belonging to this zone.
   def count_hosts
-    get('hosts/count').to_i
+    get("zones/#{id}/hosts/count.xml").body['count'].to_i
   end
 end

data/lib/zerigodns/zone_template.rb

@@ -1,15 +1,17 @@
-class ZerigoDNS::ZoneTemplate < ZerigoDNS::Base
+class ZerigoDNS::ZoneTemplate < ZerigoDNS::Client
+
+  include ZerigoDNS::Resource
   
   # Get count of zone templates
   # @return [Fixnum] the count of zone templates
   def self.count
-    get(:count).to_i
+    get('zone_templates/count.xml').body['count'].to_i
   end
   
   # Get count of host templates
   # @return [Fixnum] the count of host templates for this zone template
   def count_host_templates
-    get('host_templates/count').to_i
+    get("zone_templates/#{id}/host_templates/count.xml").body['count'].to_i
   end
   
   # Create a zone using the zone template
@@ -28,7 +30,7 @@ class ZerigoDNS::ZoneTemplate < ZerigoDNS::Base
   # List all host templates of this zone template
   # @return [Array] An array of host templates
   def host_templates
-    @host_templates ||= ZerigoDNS::HostTemplate.find(:all, params: {zone_template_id: id})
+    @host_templates ||= ZerigoDNS::HostTemplate.all(zone_template_id: id)
   end
   
   # Create a host template for this template

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zerigodns
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,16 +10,32 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activeresource
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: multi_xml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +43,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.5.5
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +108,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.1
 description: Gem for interacting with the Zerigo DNS REST API.
 email: support@zerigo.com
 executables: []
@@ -101,11 +133,19 @@ extra_rdoc_files:
 files:
 - LICENSE
 - Rakefile
-- lib/activeresource-ext.rb
-- lib/zerigodns/base.rb
+- lib/zerigodns/client/response_code.rb
+- lib/zerigodns/client.rb
 - lib/zerigodns/config.rb
 - lib/zerigodns/host.rb
 - lib/zerigodns/host_template.rb
+- lib/zerigodns/middleware/error_handler.rb
+- lib/zerigodns/middleware/xml.rb
+- lib/zerigodns/middleware/zerigo_auth.rb
+- lib/zerigodns/middleware.rb
+- lib/zerigodns/resource/attributes.rb
+- lib/zerigodns/resource/naming.rb
+- lib/zerigodns/resource/rest.rb
+- lib/zerigodns/resource.rb
 - lib/zerigodns/tools.rb
 - lib/zerigodns/zone.rb
 - lib/zerigodns/zone_template.rb

data/lib/activeresource-ext.rb

@@ -1,43 +0,0 @@
-require 'active_resource'
-require 'active_support/core_ext/module'
-
-module ActiveResource
-  module CaptureHeaders
-    module InstanceMethods
-      private
-      def request_with_headers(method, path, *arguments)
-        request_without_headers(method, path, *arguments).tap do |resp|
-          @headers = resp.to_hash
-        end
-      end
-
-    end
-
-    def self.included(receiver)
-      receiver.class_eval do
-        include InstanceMethods
-        alias_method_chain :request, :headers
-        attr :headers
-      end
-    end
-  end
-  
-  module RetrieveHeaders
-    module InstanceMethods
-      def last_count
-        @last_count ||= (c = connection.headers['x-query-count']) ? c[0].to_i : nil
-      end
-      
-    end
-    
-    def self.included(receiver)
-      receiver.class_eval do
-        include InstanceMethods
-      end
-    end
-  end
-  
-end
-
-ActiveResource::Connection.send :include, ActiveResource::CaptureHeaders
-ActiveResource::Base.send :include, ActiveResource::RetrieveHeaders

data/lib/zerigodns/base.rb

@@ -1,47 +0,0 @@
-module ZerigoDNS
-  class Base < ActiveResource::Base
-    class << self
-      attr_reader :secure
-      alias_method :api_key, :password
-      alias_method :api_key=, :password=
-      def secure=(bool)
-        @secure=bool
-        self.site = @secure ? 'https://ns.zerigo.com/api/1.1/' : 'http://ns.zerigo.com/api/1.1/'
-      end
-    end
-    
-    self.site='https://ns.zerigo.com/api/1.1/'
-    self.timeout = 5 # timeout after 5 seconds
-    self.format = ActiveResource::Formats::XmlFormat
-    @secure = true
-    
-    
-    
-    # fix load() so that it no longer clobbers @prefix_options
-    # also fix bug exposed by reload() where attributes is effectively parsed twice, causing the first line to raise an exception the 2nd time
-    def load(attributes, remove_root = false)
-      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
-      new_prefix_options, attributes = split_options(attributes)
-      @prefix_options.merge!(new_prefix_options)
-      attributes.each do |key, value|
-        @attributes[key.to_s] =
-          case value
-          when Array
-            if value.all?{|v2| v2.kind_of?(ActiveResource::Base)}
-              value.dup rescue value
-            else
-              resource = find_or_create_resource_for_collection(key)
-              value.map { |attrs| attrs.is_a?(String) ? attrs.dup : resource.new(attrs) }
-            end
-          when Hash
-            resource = find_or_create_resource_for(key)
-            resource.new(value)
-          else
-            value.dup rescue value
-          end
-      end
-      self
-    end
-  end
-end
-