glassfrog 0.3.0

data/lib/glassfrog/client.rb

@@ -0,0 +1,291 @@
+require 'http'
+require 'tmpdir'
+require 'glassfrog/utils/utils'
+require 'glassfrog/utils/graph'
+require 'glassfrog/action'
+require 'glassfrog/checklist_item'
+require 'glassfrog/circle'
+require 'glassfrog/metric'
+require 'glassfrog/person'
+require 'glassfrog/project'
+require 'glassfrog/role'
+require 'glassfrog/trigger'
+
+module Glassfrog
+  # 
+  # Encapsulates HTTP/GlassFrog message sending.
+  # 
+  class Client
+    include Glassfrog::Utils
+    # @return [String]
+    attr_accessor :api_key
+    # @return [HTTP]
+    attr_reader :http
+    # @return [Boolean]
+    attr_reader :caching
+    # @return [Hash]
+    attr_reader :caching_settings
+    # @return [TempFile]
+    attr_reader :cache_meta, :cache_entity
+    CACHE = 'glassfrog-cache-'
+
+    TYPES = {
+              action: Glassfrog::Action,
+      checklist_item: Glassfrog::ChecklistItem,
+              circle: Glassfrog::Circle,
+              metric: Glassfrog::Metric,
+              person: Glassfrog::Person,
+             project: Glassfrog::Project,
+                role: Glassfrog::Role,
+             trigger: Glassfrog::Trigger
+    }
+
+    TYPES.merge!({
+              actions: TYPES[:action],
+      checklist_items: TYPES[:checklist_item],
+              circles: TYPES[:circle],
+              metrics: TYPES[:metric],
+               people: TYPES[:person],
+             projects: TYPES[:project],
+                roles: TYPES[:role],
+             triggers: TYPES[:trigger]
+    })
+
+    ASSOCIATED_PARAMS = {
+      Glassfrog::Role => {
+        Glassfrog::Circle =>  [:circle_id, :id],
+        Glassfrog::Person =>  [:person_id, :id]
+        },
+      Glassfrog::Person => {
+        Glassfrog::Circle =>  [:circle_id, :id],
+          Glassfrog::Role =>  [:role, :name]
+        },
+      Glassfrog::Project => {
+        Glassfrog::Circle =>  [:circle_id, :id],
+        Glassfrog::Person =>  [:person_id, :id]
+        },
+      Glassfrog::Metric => {
+        Glassfrog::Circle =>  [:circle_id, :id],
+          Glassfrog::Role =>  [:role_id, :id]
+        },
+      Glassfrog::ChecklistItem => {
+        Glassfrog::Circle =>  [:circle_id, :id]
+        },
+      Glassfrog::Action => {
+        Glassfrog::Person =>  [:person_id, :id],
+        Glassfrog::Circle =>  [:circle_id, :id]
+        },
+      Glassfrog::Trigger => {
+        Glassfrog::Person =>  [:person_id, :id],
+        Glassfrog::Circle =>  [:circle_id, :id]
+      }
+    }
+
+    # 
+    # Initializes a new Client object.
+    # @param attrs={} [Hash, String] Either just the API key, or a Hash of options.
+    # 
+    # @return [Glassfrog::Client] The initialized Client object.
+    def initialize(attrs={})
+      if attrs.class == String
+        @api_key = attrs
+      elsif attrs.class == Hash
+        attrs.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      else
+        raise(ArgumentError, 'Invalid Arguements. Must be String or Hash.')
+      end
+      yield(self) if block_given?
+      @caching ||= nil
+      @caching = @caching || (@caching.nil? && @caching_settings)
+      tmpdir = @caching ? setup_cache : nil
+      ObjectSpace.define_finalizer(self, self.class.finalize(tmpdir)) if tmpdir
+      @http = @caching ? HTTP.cache({ metastore: @cache_meta, entitystore: @cache_entity }) : HTTP
+    end
+
+    # 
+    # Sends a GET request to the corresponding object type.
+    # @param type [Glassfrog::Base] Object type to send request to.
+    # @param options={} [Hash, Glassfrog::Base, Integer, String, URI] Options to specify object(s) to fetch.
+    # 
+    # @return [Array<Glassfrog::Base>] The fetched object(s).
+    def get(type, options={})
+      klass = TYPES[parameterize(type)]
+      options = parse_params(options, klass)
+      klass.public_send(:get, self, options)
+    end
+
+    # 
+    # Sends a POST request to the corresponding object type.
+    # @param type [Glassfrog::Base] Object type to send request to.
+    # @param options={} [Hash, Glassfrog::Base] Options to specify attribute(s) of object being created.
+    # 
+    # @return [Array<Glassfrog::Base>] The created object.
+    def post(type, options)
+      klass = TYPES[parameterize(type)]
+      options = validate_options(options, klass)
+      klass.public_send(:post, self, options)
+    end
+
+    # 
+    # Sends a PATCH request to the corresponding object type.
+    # @param type [Glassfrog::Base] Object type to send request to.
+    # @param identifier=nil [Integer] The ID of the object to update.
+    # @param options={} [Hash, Glassfrog::Base] Options to specify attribute(s) to update and/or ID.
+    # 
+    # @return [Hash, Glassfrog::Base, Integer, String, URI, Boolean] The options passed if successful or false if unsuccessful.
+    def patch(type, identifier=nil, options)
+      klass = TYPES[parameterize(type)]
+      identifier = extract_id(options, klass) if identifier.nil?
+      raise(ArgumentError, "No valid id found given in options") if identifier.nil?
+      options = validate_options(options, klass)
+      if klass.public_send(:patch, self, identifier, options) then options else false end
+    end
+
+    # 
+    # Sends a DELETE request to the corresponding object type.
+    # @param type [Glassfrog::Base] Object type to send request to.
+    # @param options={} [Hash, Glassfrog::Base, Integer, String, URI] Options to specify the ID of the object to delete.
+    # 
+    # @return [Boolean] Whether the request was successful.
+    def delete(type, options)
+      klass = TYPES[parameterize(type)]
+      identifier = extract_id(options, klass)
+      raise(ArgumentError, "No valid id found given in options") unless identifier
+      if klass.public_send(:delete, self, { id: identifier }) then true else false end
+    end
+
+    # 
+    # Builds the organization's circle hierarchy.
+    # @param circles=nil [Array<Glassfrog::Circle>] Array of circle objects (used instead of a GET request).
+    # @param roles=nil [Array<Glassfrog::Role>] Array of role objects (used instead of a GET request).
+    # 
+    # @return [Glassfrog::Circle] The root circle.
+    def build_hierarchy(circles=nil, roles=nil)
+      Glassfrog::Graph.hierarchy(self, circles, roles)
+    end
+
+    # 
+    # Find the root circle of an array of circles.
+    # @param circles=nil [Array<Glassfrog::Circle>] Array of circle objects of which the root will be found.
+    # @param roles=nil [Array<Glassfrog::Role>] Array of role objects to use to find supporting role of the root circle.
+    # 
+    # @return [Glassfrog::Circle] The root circle.
+    def find_root(circles=nil, roles=nil)
+      circles ||= self.get :circles
+      roles ||= self.get :roles
+      Glassfrog::Graph.root(circles, roles)
+    end
+
+    # 
+    # Gets the HTTP headers for requests.
+    # 
+    # @return [Hash] The headers.
+    def headers
+      { 'X-Auth-Token' => self.api_key }
+    end
+
+    # 
+    # Checks if there is an API Key.
+    # 
+    # @return [Boolean] Whether there is an API Key.
+    def api_key?
+      !!(api_key)
+    end
+
+    # 
+    # Allow @caching to be set only once. Otherwise throw error.
+    # @param value [Boolean] Whether caching should be on or off.
+    # 
+    # @return [Boolean] The value.
+    def caching=(value)
+      defined?(@caching) ? raise(ArgumentError, "Caching is already set.") : @caching = value
+    end
+
+    # 
+    # Allow @caching_settings to be set only once. Otherwise throw error.
+    # @param value [Hash] The caching settings.
+    # 
+    # @return [Hash] The settings that have been set.
+    def caching_settings=(value)
+      defined?(@caching_settings) ? raise(ArgumentError, "Caching Settings are already set.") : @caching_settings = value
+    end
+
+    # 
+    # Garbage collection finalizer for the cache directory; if a cache directory was created it will be deleted with the Client object.
+    # @param tmpdir [String] Path to the temporary directory.
+    # 
+    # @return [Proc] Proc containing the directory deletion.
+    def self.finalize(tmpdir)
+      proc { FileUtils.remove_entry(tmpdir) }
+    end
+
+    private
+
+    # 
+    # Parses the meta and entity store locations or sets to the defaults (temporary files).
+    # 
+    # @return [String] If a temporary cache directory was created, returns that path string (or nil).
+    def setup_cache
+      @caching_settings ||= {}
+      @cache_tmpdir ||= Dir.mktmpdir(CACHE) unless @caching_settings[:metastore]
+      @cache_meta = @caching_settings[:metastore] || ('file:' + @cache_tmpdir + '/meta')
+      @cache_tmpdir ||= Dir.mktmpdir(CACHE) unless @caching_settings[:entitystore]
+      @cache_entity = @caching_settings[:entitystore] || ('file:' + @cache_tmpdir + '/entity')
+      @cache_tmpdir || nil
+    end
+
+    # 
+    # Extracts the ID from options and validates the options before a request.
+    # @param options [Hash, Glassfrog::Base, Integer, String, URI] Options passed to the request.
+    # @param klass [Class] The class of the object being targeted.
+    # 
+    # @return [Hash] The parameters to pass to the request.
+    def parse_params(options, klass)
+      options = symbolize_keys(options)
+      id = extract_id(options, klass)
+      params = id ? { id: id } : parse_associated_params(options, klass)
+      validate_params(params, klass)
+    end
+
+    # 
+    # Checks if an associated object was passed as options.
+    # @param options [Hash, Glassfrog::Base, Integer, String, URI] Options passed to the request.
+    # @param klass [Class] The class of the object being targeted.
+    # 
+    # @return [Hash, Glassfrog::Base, Integer, String, URI] The associated object parameter in a hash or options.
+    def parse_associated_params(options, klass)
+      associated_param = ASSOCIATED_PARAMS[klass] && ASSOCIATED_PARAMS[klass][options.class] ? ASSOCIATED_PARAMS[klass][options.class] : nil
+      if associated_param
+        key, method = associated_param
+        method == :name ? { key => parameterize(options.public_send(method)) } : { key => options.public_send(method) }
+      else 
+        options
+      end
+    end
+
+    # 
+    # Checks if options are valid.
+    # @param options [Hash, Glassfrog::Base, Integer, String, URI] Options passed to the request.
+    # @param klass [Class] The class of the object being targeted.
+    # 
+    # @return [Hash, Integer, String, URI] If valid options, if invalid raises error.
+    def validate_options(options, klass)
+      raise(ArgumentError, "Options cannot be " + options.class.name) unless options.is_a?(klass) || options.is_a?(Hash)
+      options.is_a?(Glassfrog::Base) ? options.hashify : options
+    end
+
+    # 
+    # Checks if options are valid or if they are an associated object.
+    # @param params [Hash, Glassfrog::Base, Integer, String, URI] Options passed to the request.
+    # @param klass [Class] The class of the object being targeted.
+    # 
+    # @return [Hash, Integer, String, URI] If valid params, if invalid raises error.
+    def validate_params(params, klass)
+      raise(ArgumentError, "Options cannot be " + params.class.name) unless params.is_a?(klass) || params.is_a?(Hash) || 
+        (ASSOCIATED_PARAMS[klass] && ASSOCIATED_PARAMS[klass].keys.include?(params.class))
+      params.is_a?(Glassfrog::Base) ? params.hashify : params
+    end
+  end
+end

data/lib/glassfrog/error.rb

@@ -0,0 +1,97 @@
+module Glassfrog
+  # 
+  # Encapsulates GlassFrog HTTP errors.
+  # 
+  class Error < StandardError
+    # @return [Integer]
+    attr_reader :code
+
+    # Raised with a 4xx HTTP status code
+    ClientError = Class.new(self)
+    # Raised with the HTTP status code 400
+    BadRequest = Class.new(ClientError)
+    # Raised with the HTTP status code 401
+    Unauthorized = Class.new(ClientError)
+    # Raised with the HTTP status code 403
+    Forbidden = Class.new(ClientError)
+    # Raised with the HTTP status code 404
+    NotFound = Class.new(ClientError)
+    # Raised with the HTTP status code 406
+    NotAcceptable = Class.new(ClientError)
+    # Raised with the HTTP status code 422
+    UnprocessableEntity = Class.new(ClientError)
+    # Raised with the HTTP status code 429
+    TooManyRequests = Class.new(ClientError)
+    # Raised with a 5xx HTTP status code
+    ServerError = Class.new(self)
+    # Raised with the HTTP status code 500
+    InternalServerError = Class.new(ServerError)
+    # Raised with the HTTP status code 502
+    BadGateway = Class.new(ServerError)
+    # Raised with the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+    # Raised with the HTTP status code 504
+    GatewayTimeout = Class.new(ServerError)
+
+    ERRORS = {
+      400 => Glassfrog::Error::BadRequest,
+      401 => Glassfrog::Error::Unauthorized,
+      403 => Glassfrog::Error::Forbidden,
+      404 => Glassfrog::Error::NotFound,
+      406 => Glassfrog::Error::NotAcceptable,
+      422 => Glassfrog::Error::UnprocessableEntity,
+      429 => Glassfrog::Error::TooManyRequests,
+      500 => Glassfrog::Error::InternalServerError,
+      502 => Glassfrog::Error::BadGateway,
+      503 => Glassfrog::Error::ServiceUnavailable,
+      504 => Glassfrog::Error::GatewayTimeout,
+    }
+
+    # 
+    # GlassFrog HTTP errors.
+    # 
+    class << self
+      #
+      # Create a new error from an HTTP response.
+      # @param code [Integer] The HTTP response code.
+      # @param body [String] The HTTP response body.
+      # @param headers [Hash] The HTTP response headers.
+      # 
+      # @return [Glassfrog::Error] The corresponding error for the code.
+      def from_response(code, body, headers)
+        message = parse_error(code, body, headers)
+        new(message, code)
+      end
+
+      private
+
+      # 
+      # Returns a corresponding message for a GlassFrog error.
+      # @param code [Integer] The HTTP response code.
+      # @param body [String] The HTTP response body.
+      # @param headers [Hash] The HTTP response headers.
+      # 
+      # @return [String, Integer] A meaningful message or the error code.
+      def parse_error(code, body, headers)
+        if body.content_type['mime_type'] == 'application/json' && body.parse['message']
+          body.parse['message']
+        elsif body.content_type['mime_type'] == 'text/html' && headers['Status']
+          headers['Status']
+        else 
+          code
+        end
+      end
+    end
+
+    # 
+    # Initializes a new Error object.
+    # @param message = '' [String] Meaningful message about the error.
+    # @param code = nil [Integer] The HTTP response code.
+    # 
+    # @return [Glassfrog::Error] The initialized Error.
+    def initialize(message = '', code = nil)
+      super(message)
+      @code = code
+    end
+  end
+end

data/lib/glassfrog/metric.rb

@@ -0,0 +1,90 @@
+require 'glassfrog/base'
+require 'glassfrog/rest/get'
+require 'glassfrog/rest/post'
+require 'glassfrog/rest/patch'
+require 'glassfrog/rest/delete'
+
+module Glassfrog
+  # 
+  # Encapsulates GlassFrog Metrics.
+  # 
+  class Metric < Glassfrog::Base
+    # @return [String]
+    attr_accessor :description, :frequency, :link, :role_name
+    # @return [Boolean]
+    attr_accessor :global
+    # @return [Hash]
+    attr_accessor :links
+    PATH = '/metrics'
+    TYPE = :metrics
+
+    # 
+    # Sends a GET request for Metric(s) to GlassFrog.
+    # @param client [Glassfrog::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options used to find the correct Metrics(s).
+    # 
+    # @return [Array<Glassfrog::Metric>] The array of Metric(s) fetched from GlassFrog.
+    def self.get(client, options)
+      response = Glassfrog::REST::Get.irregular_get(client, TYPE, PATH, options)
+      response[TYPE] ? response[TYPE].map { |object| self.new(object) } : []
+    end
+
+    # 
+    # Sends a POST request to create a Metric on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassforg::Base] The options used to create the new Metrics.
+    # 
+    # @return [Array<Glassfrog::Metric>] The array containing the new Metric.
+    def self.post(client, options)
+      response = Glassfrog::REST::Post.post(client, PATH, { TYPE => [parse_options(options)] })
+      response[TYPE] ? response[TYPE].map { |object| self.new(object) } : []
+    end
+
+    # 
+    # Sends a PATCH request to update a Metric on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param identifier [Integer] The ID of the Metric to be updated.
+    # @param options [Hash, Glassfrog::Base] The options used to update the Metric.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.patch(client, identifier, options)
+      options = Glassfrog::REST::Patch.formify(parse_options(options), self)
+      response = Glassfrog::REST::Patch.patch(client, PATH + '/' + identifier.to_s, options)
+    end
+
+    # 
+    # Sends a DELETE request to delete a Metric on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options containing the ID of the Metric to delete.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.delete(client, options)
+      path = PATH + '/' + options.delete(:id).to_s
+      response = Glassfrog::REST::Delete.delete(client, path, options)
+    end
+
+    private
+
+    PARAMS = [
+      :description,
+      :frequency,
+      :global,
+      :link,
+      :circle_id,
+      :role_id
+    ]
+
+    # 
+    # Grabs only the parameters accepted by GlassFrog.
+    # @param options [Hash] Inputed options.
+    # 
+    # @return [Hash] Valid GlassFrog options.
+    def self.parse_options(options)
+      options[:circle_id] = options[:links][:circle] if options[:links] && options[:links][:circle]
+      options[:role_id] = options[:links][:role] if options[:links] && options[:links][:role]
+      params_hash = Hash.new
+      PARAMS.each { |param| params_hash[param] = options[param] if options[param] }
+      params_hash
+    end
+  end
+end

data/lib/glassfrog/person.rb

@@ -0,0 +1,84 @@
+require 'glassfrog/base'
+require 'glassfrog/rest/get'
+require 'glassfrog/rest/post'
+require 'glassfrog/rest/patch'
+require 'glassfrog/rest/delete'
+
+module Glassfrog
+  # 
+  # Encapsulates GlassFrog People.
+  # 
+  class Person < Glassfrog::Base
+    # @return [String]
+    attr_accessor :name, :email
+    # @return [Integer]
+    attr_accessor :external_id
+    # @return [Hash]
+    attr_accessor :links
+    PATH = '/people'
+    TYPE = :people
+
+    # 
+    # Sends a GET request for Person(s) to GlassFrog.
+    # @param client [Glassfrog::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options used to find the correct Persons(s).
+    # 
+    # @return [Array<Glassfrog::Person>] The array of Person(s) fetched from GlassFrog.
+    def self.get(client, options)
+      response = Glassfrog::REST::Get.get(client, PATH, options)
+      response[TYPE].map { |object| self.new(object) }
+    end
+
+    # 
+    # Sends a POST request to create a Person on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassforg::Base] The options used to create the new Persons.
+    # 
+    # @return [Array<Glassfrog::Person>] The array containing the new Person.
+    def self.post(client, options)
+      response = Glassfrog::REST::Post.post(client, PATH, { TYPE => [parse_options(options)] })
+      response[TYPE].map { |object| self.new(object) }
+    end
+
+    # 
+    # Sends a PATCH request to update a Person on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param identifier [Integer] The ID of the Person to be updated.
+    # @param options [Hash, Glassfrog::Base] The options used to update the Person.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.patch(client, identifier, options)
+      options = Glassfrog::REST::Patch.formify(parse_options(options), self)
+      response = Glassfrog::REST::Patch.patch(client, PATH + '/' + identifier.to_s, options)
+    end
+
+    # 
+    # Sends a DELETE request to delete a Person on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options containing the ID of the Person to delete.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.delete(client, options)
+      path = PATH + '/' + options.delete(:id).to_s
+      response = Glassfrog::REST::Delete.delete(client, path, options)
+    end
+
+    private
+
+    PARAMS = [
+      :name,
+      :email
+    ]
+
+    # 
+    # Grabs only the parameters accepted by GlassFrog.
+    # @param options [Hash] Inputed options.
+    # 
+    # @return [Hash] Valid GlassFrog options.
+    def self.parse_options(options)
+      params_hash = Hash.new
+      PARAMS.each { |param| params_hash[param] = options[param] if options[param] }
+      params_hash
+    end
+  end
+end

data/lib/glassfrog/project.rb

@@ -0,0 +1,97 @@
+require 'glassfrog/base'
+require 'glassfrog/rest/get'
+require 'glassfrog/rest/post'
+require 'glassfrog/rest/patch'
+require 'glassfrog/rest/delete'
+
+module Glassfrog
+  # 
+  # Encapsulates GlassFrog Projects.
+  # 
+  class Project < Glassfrog::Base
+    # @return [String]
+    attr_accessor :description, :status, :link, :created_at, :archived_at
+    # @return [Integer]
+    attr_accessor :value, :effort, :roi
+    # @return [Boolean]
+    attr_accessor :private_to_circle
+    # @return [Hash]
+    attr_accessor :links
+    PATH = '/projects'
+    TYPE = :projects
+
+    # 
+    # Sends a GET request for Project(s) to GlassFrog.
+    # @param client [Glassfrog::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options used to find the correct Projects(s).
+    # 
+    # @return [Array<Glassfrog::Project>] The array of Project(s) fetched from GlassFrog.
+    def self.get(client, options)
+      response = Glassfrog::REST::Get.get(client, PATH, options)
+      response[TYPE].map { |object| self.new(object) }
+    end
+
+    # 
+    # Sends a POST request to create a Project on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassforg::Base] The options used to create the new Projects.
+    # 
+    # @return [Array<Glassfrog::Project>] The array containing the new Project.
+    def self.post(client, options)
+      response = Glassfrog::REST::Post.post(client, PATH, { TYPE => [parse_options(options)] })
+      response[TYPE].map { |object| self.new(object) }
+    end
+
+    # 
+    # Sends a PATCH request to update a Project on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param identifier [Integer] The ID of the Project to be updated.
+    # @param options [Hash, Glassfrog::Base] The options used to update the Project.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.patch(client, identifier, options)
+      options = Glassfrog::REST::Patch.formify(parse_options(options), self)
+      response = Glassfrog::REST::Patch.patch(client, PATH + '/' + identifier.to_s, options)
+    end
+
+    # 
+    # Sends a DELETE request to delete a Project on GlassFrog.
+    # @param client [Glassforg::Client] The client that will send the request. Contains the API key.
+    # @param options [Hash, Glassfrog::Base] The options containing the ID of the Project to delete.
+    # 
+    # @return [Boolean] Whether the request failed or not.
+    def self.delete(client, options)
+      path = PATH + '/' + options.delete(:id).to_s
+      response = Glassfrog::REST::Delete.delete(client, path, options)
+    end
+
+    private
+
+    PARAMS = [
+      :description,
+      :status,
+      :link,
+      :value,
+      :effort,
+      :private_to_circle,
+      :archived_at,
+      :circle_id,
+      :role_id,
+      :person_id
+    ]
+
+    # 
+    # Grabs only the parameters accepted by GlassFrog.
+    # @param options [Hash] Inputed options.
+    # 
+    # @return [Hash] Valid GlassFrog options.
+    def self.parse_options(options)
+      options[:circle_id] = options[:links][:circle] if options[:links] && options[:links][:circle]
+      options[:role_id] = options[:links][:role] if options[:links] && options[:links][:role]
+      options[:person_id] = options[:links][:person] if options[:links] && options[:links][:person]
+      params_hash = Hash.new
+      PARAMS.each { |param| params_hash[param] = options[param] if options[param] }
+      params_hash
+    end
+  end
+end

data/lib/glassfrog/rest/delete.rb

@@ -0,0 +1,21 @@
+require 'glassfrog/rest/request'
+
+module Glassfrog
+  module REST
+      # 
+      # Encapsulates all DELETE requests.
+      # 
+    module Delete
+      # 
+      # Sends a DELETE request.
+      # @param client [Glassfrog::Client] Client that will send the request.
+      # @param path [String] Path to send request to.
+      # @param options [Hash] Options being sent in the request.
+      # 
+      # @return [Boolean] Whether request was successful.
+      def self.delete(client, path, options)
+        Glassfrog::REST::Request.new(client, :delete, path, options).perform
+      end
+    end
+  end
+end