point 1.0.0

data/lib/point.rb

@@ -0,0 +1,27 @@
+## Require dependencies. All network traffic is processed using net/http and
+## is transfered using JSON.
+require 'json'
+require 'uri'
+require 'net/http'
+
+## PointHQ Ruby API Client
+## This is a ruby API client for the Point DNS hosting service.
+
+require 'point/request'
+require 'point/errors'
+require 'point/base'
+require 'point/zone'
+require 'point/zone_record'
+
+module Point
+  VERSION = '1.0.0'
+  
+  class << self
+    attr_accessor :username
+    attr_accessor :apitoken
+    attr_accessor :site
+  end
+  
+end
+
+Point.site = "http://pointhq.com"

data/lib/point/base.rb

@@ -0,0 +1,160 @@
+module Point
+  class Base
+    
+    ## Store all attributes for the model we're working with.
+    attr_accessor :id, :attributes, :errors
+    
+    ## Pass any methods via. the attributes hash to see if they exist
+    ## before resuming normal method_missing behaviour
+    def method_missing(method, *params)
+      set = method.to_s.include?('=')
+      key = method.to_s.sub('=', '')
+      self.attributes = Hash.new unless self.attributes.is_a?(Hash)
+      if set
+        self.attributes[key] = params.first
+      else
+        self.attributes[key]
+      end
+    end
+    
+    class << self
+      
+      ## Find a record or set of records. Passing :all will return all records and passing an integer
+      ## will return the individual record for the ID passed.
+      def find(type, params = {})
+        case type
+        when :all then find_all(params)
+        when Integer then find_single(type, params)
+        end
+      end
+      
+      ## Find all objects and return an array of objects with the attributes set.
+      def find_all(params)
+        JSON.parse(Request.new(collection_path(params)).make.output).map do |o|
+          create_object(o[class_name.downcase], params)
+        end
+      end
+      
+      ## Find a single object and return an object for it.
+      def find_single(id, params = {})
+        o = JSON.parse(Request.new(member_path(id, params)).make.output)
+        if o[class_name.downcase]
+          create_object(o[class_name.downcase], params)
+        else
+          raise Point::Errors::NotFound, "Record not found"
+        end
+      end
+      
+      ## Post to the specified object on the collection path
+      def post(path)
+        Request.new(path.to_s, :post).make
+      end
+      
+      ## Return the collection path for this model. Very lazy pluralizion here
+      ## at the moment, nothing in Point needs to be pluralized with anything
+      ## other than just adding an 's'.
+      def collection_path(params = {})
+        class_name.downcase + 's'
+      end
+      
+      ## Return the member path for the passed ID & attributes
+      def member_path(id, params = {})
+        [collection_path, id].join('/')
+      end
+      
+      ## Return the point class name
+      def class_name
+        self.name.to_s.split('::').last.downcase
+      end
+      
+      private
+            
+      ## Create a new object with the specified attributes and getting and ID. 
+      ## Returns the newly created object
+      def create_object(attributes, objects = [])
+        o = self.new
+        o.attributes = attributes
+        o.id         = attributes['id']
+        for key, object in objects.select{|k,v| v.kind_of?(Point::Base)}
+          o.attributes[key.to_s] = object
+        end
+        o
+      end
+    end
+    
+    ## Run a post on the member path. Returns the ouput from the post, false if a conflict or raises
+    ## a Point::Error. Optionally, pass a second 'data' parameter to send data to the post action.
+    def post(action, data = nil)
+      path = self.class.member_path(self.id, default_params) + "/" + action.to_s
+      request = Request.new(path, :post)
+      request.data = data
+      request.make
+    end
+    
+    ## Delete this record from the remote service. Returns true or false depending on the success
+    ## status of the destruction.
+    def destroy
+      Request.new(self.class.member_path(self.id, default_params), :delete).make.success?
+    end
+    
+    def new_record?
+      self.id.nil?
+    end
+    
+    def save
+      new_record? ? create : update
+    end
+
+    def create
+      request = Request.new(self.class.collection_path(default_params), :post)
+      request.data = {self.class.class_name.downcase.to_sym => attributes_to_post}
+      if request.make && request.success?
+        new_record = JSON.parse(request.output)[self.class.class_name]
+        self.id = new_record['id']
+        true
+      else
+        populate_errors(request.output)
+        false
+      end
+    end
+
+    ## Push the updated attributes to the remote. Returns true if the record was saved successfully
+    ## other false if not. If not saved successfully, the errors hash will be updated with an array
+    ## of all errors with the submission.    
+    def update
+      request = Request.new(self.class.member_path(self.id, default_params), :put)
+      request.data = {self.class.class_name.downcase.to_sym => attributes_to_post}
+      if request.make && request.success?
+        true
+      else
+        populate_errors(request.output)
+        false
+      end
+    end
+    
+    private
+    
+    ## Populate the errors hash from the given raw JSON output
+    def populate_errors(json)
+      self.errors = Hash.new
+      JSON.parse(json).inject(self.errors) do |r, e|
+        r[e.first] = e.last
+        r
+      end
+    end
+    
+    ## An array of params which should always be sent with this instances requests
+    def default_params
+      Hash.new
+    end
+    
+    ## Attributes which can be passed for update & creation
+    def attributes_to_post
+      self.attributes.inject(Hash.new) do |r,(key,value)|
+        r[key] = value if value.is_a?(String) || value.is_a?(Integer) || value.is_a?(Fixnum)
+        r
+      end
+    end
+    
+  end
+end

data/lib/point/errors.rb

@@ -0,0 +1,20 @@
+module Point
+  
+  ## Base level error which all other point errors will inherit from. It may also be
+  ## invoked for errors which don't directly relate to other errors below.
+  class Error < StandardError; end
+  
+  module Errors
+    
+    ## The service is currently unavailable. This may be caused by rate limiting or the API
+    ## or the service has been disabled by the system
+    class ServiceUnavailable < Error; end
+    
+    ## Access was denied to the remote service
+    class AccessDenied < Error; end
+    
+    ## A communication error occured while talking to the Point API
+    class CommunicationError < Error; end
+        
+  end
+end

data/lib/point/request.rb

@@ -0,0 +1,63 @@
+module Point
+  class Request
+    
+    attr_reader :path, :method
+    attr_accessor :data
+    
+    def initialize(path, method = :get)
+      @path = path
+      @method = method
+    end
+    
+    def success?
+      @success || false
+    end
+    
+    def output
+      @output || nil
+    end
+    
+    ## Make a request to the Point API using net/http. Data passed can be a hash or a string
+    ## Hashes will be converted to JSON before being sent to the remote service.
+    def make
+      uri = URI.parse([Point.site, @path].join('/'))
+      http_request = http_class.new(uri.path)
+      http_request.basic_auth(Point.username, Point.apitoken)
+      http_request.add_field("Accept", "application/json")
+      http_request.add_field("Content-type", "application/json")
+      
+      http = Net::HTTP.new(uri.host, uri.port)
+      data = self.data.to_json if self.data.is_a?(Hash) && self.data.respond_to?(:to_json)
+      http_result = http.request(http_request, data)
+      @output = http_result.body
+      @success = case http_result
+      when Net::HTTPSuccess
+        true
+      when Net::HTTPServiceUnavailable
+        raise Point::Errors::ServiceUnavailable
+      when Net::HTTPForbidden, Net::HTTPUnauthorized
+        raise Point::Errors::AccessDenied, "Access Denied for '#{Point.username}'"
+      when Net::HTTPNotFound
+        raise Point::Errors::CommunicationError, "Not Found at #{uri.to_s}"
+      when Net::HTTPClientError
+        false
+      else
+        raise Point::Errors::CommunicationError, http_result.body
+      end
+      self
+    end
+    
+    private
+    
+    def http_class  
+      case @method
+      when :post    then Net::HTTP::Post
+      when :put     then Net::HTTP::Put
+      when :delete  then Net::HTTP::Delete
+      else
+        Net::HTTP::Get
+      end
+    end
+    
+  end
+end

data/lib/point/zone.rb

@@ -0,0 +1,24 @@
+module Point
+  class Zone < Base
+    
+    def apply!
+      post(:apply)
+    end
+    
+    def records
+      ZoneRecord.find(:all, :zone => self)
+    end
+    
+    def record(id)
+      ZoneRecord.find(id, :zone => self)
+    end
+    
+    def build_record(attributes = {})
+      z = ZoneRecord.new
+      z.attributes = attributes if attributes.is_a?(Hash)
+      z.zone = self
+      z
+    end
+    
+  end
+end

data/lib/point/zone_record.rb

@@ -0,0 +1,23 @@
+module Point
+  class ZoneRecord < Base
+    
+    class << self
+      def collection_path(params = {})
+        "zones/#{params[:zone].id}/records"
+      end
+      
+      def member_path(id, params = {})
+        "zones/#{params[:zone].id}/records/#{id}"
+      end
+      
+      def class_name
+        "zone_record"
+      end
+    end
+    
+    def default_params
+      {:zone => self.zone}
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: point
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-29 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.5
+    version: 
+description: 
+email: adam@atechmedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/point/base.rb
+- lib/point/errors.rb
+- lib/point/request.rb
+- lib/point/zone.rb
+- lib/point/zone_record.rb
+- lib/point.rb
+has_rdoc: true
+homepage: http://www.pointhq.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: API client for the PointHQ DNS Hosting System
+test_files: []
+