yammer-client 0.1.0

data/lib/yammer/client.rb

@@ -0,0 +1,101 @@
+require 'multi_json'
+require 'yammer/configurable'
+require 'yammer/http_connection'
+require 'yammer/api'
+
+module Yammer
+  class Client
+    include Yammer::Configurable
+    include Yammer::Api::User
+    include Yammer::Api::Group
+    include Yammer::Api::GroupMembership
+    include Yammer::Api::Message
+    include Yammer::Api::Thread
+    include Yammer::Api::Topic
+    include Yammer::Api::Network
+    include Yammer::Api::Search
+    include Yammer::Api::Notification
+    include Yammer::Api::Autocomplete    
+
+    attr_writer :connection_options
+    attr_accessor :site_url, :http_adapter
+
+    def initialize(opts={})
+      Yammer::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", opts.fetch(key, Yammer.instance_variable_get(:"@#{key}")))
+      end
+    end
+
+    # @return [Hash] the options used to setup the http connection
+    def connection_options
+      @connection_options ||= {}
+    end
+
+    # set the url to be used for creating an http connection
+    # @param url [string]
+    def site_url=(url)
+      @connection = nil
+      @site_url = url
+    end
+
+    # (see #request)
+    # @note makes a GET request
+    def get(path, params={})
+      request(:get, path, params)
+    end
+
+    # (see #request)
+    # @note makes a PUT request
+    def put(path, params={})
+      request(:put, path, params)
+    end
+
+    # (see #request)
+    # @note makes a POST request
+    def post(path, params={})
+      request(:post, path, params)
+    end
+
+    # (see #request)
+    # @note makes a DELETE request
+    def delete(path, params={})
+      request(:delete, path, params)
+    end
+
+  private
+
+    # Makes an HTTP request using the provided parameters
+    # @raise [Yammer::Error::Unauthorized]
+    # @param method [string]  
+    # @param path [string]
+    # @param params [Hash]
+    # @param opts [Hash]
+    # @return [Yammer::Response]
+    # @!visibility private
+    def request(method, path, params={}, opts={})
+      # Log request here
+      response = connection.send_request(method, path, {
+        :params  => params,
+        :headers => {
+          'Authorization' => "Bearer #{@access_token}"
+        }
+      })
+      result = Yammer::Response.new(response)
+      status = result.code
+      case status
+      when 200...400
+        result
+      else
+        message = result.empty? ? '' : result.body[:response][:message]
+        raise Yammer::Error.from_status(status).new(message)
+      end
+    end
+
+    # returns an instance of the http adapter
+    # if none is specified, the default is Yammer::HttpConnection
+    # @!visibility private
+    def connection
+      @connection ||= @http_adapter.new(@site_url, connection_options)
+    end
+  end
+end

data/lib/yammer/configurable.rb

@@ -0,0 +1,46 @@
+module Yammer
+  module Configurable
+
+    ENDPOINT = 'https://www.yammer.com' unless defined? ENDPOINT
+    HTTP_CONNECTION = Yammer::HttpConnection unless defined? HTTP_CONNECTION
+
+    attr_accessor :hostname, :client_id, :client_secret, :access_token, :site_url, :http_adapter,
+    :connection_options
+
+    # Return a hash with the default options
+    # @return [Hash]
+    def self.default_options
+      {
+        :site_url           => ENDPOINT,
+        :client_id          => ENV['YAMMER_CLIENT_ID'],
+        :client_secret      => ENV['YAMMER_CLIENT_SECRET'],
+        :access_token       => ENV['YAMMER_ACCESS_TOKEN'],
+        :http_adapter       => HTTP_CONNECTION,
+        :connection_options => { :max_redirects => 5, :use_ssl => true }
+      }
+    end
+
+    # @return [Array<String>
+    def self.keys
+      Yammer::Configurable.default_options.keys
+    end
+
+    # @return [Hash]
+    def options
+      Hash[Yammer::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+    def reset!
+      Yammer::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Yammer::Configurable.default_options[key.to_sym])
+      end
+      self
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+      self
+    end
+  end
+end

data/lib/yammer/error.rb

@@ -0,0 +1,61 @@
+module Yammer
+  module Error
+
+    class << self
+      def from_status(status=nil)
+        case status
+        when 400
+          BadRequest
+        when 401
+          Unauthorized
+        when 403
+          Forbidden
+        when 404
+          NotFound
+        when 406
+          NotAcceptable
+        when 429
+          RateLimitExceeded
+        when 500
+          InternalServerError
+        when 502
+          BadGateway
+        when 503
+          ServiceUnavailable
+        else
+          ApiError
+        end
+      end
+    end
+
+    # Raised when Yammer returns unknown HTTP status code
+    class ApiError < StandardError;  end
+
+    # Raised when Yammer returns the HTTP status code 400
+    class BadRequest < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 401
+    class Unauthorized < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 403
+    class Forbidden < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 404
+    class NotFound < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 406
+    class NotAcceptable < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 429
+    class RateLimitExceeded < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 500
+    class InternalServerError < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 502
+    class BadGateway < ApiError; end
+
+    # Raised when Yammer returns the HTTP status code 503
+    class ServiceUnavailable < ApiError; end
+  end
+end

data/lib/yammer/http_connection.rb

@@ -0,0 +1,184 @@
+begin
+  require 'net/https'
+rescue LoadError
+  warn "Warning: no such file to load -- net/https. Make sure openssl is installed if you want ssl support"
+  require 'net/http'
+end
+require 'zlib'
+require 'addressable/uri'
+
+module Yammer
+  class HttpConnection
+
+    class UnhandledHTTPMethodError < StandardError; end
+    class UnsupportedSchemeError < StandardError; end
+
+    NET_HTTP_EXCEPTIONS = [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EINVAL,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      SocketError,
+      Zlib::GzipFile::Error,
+    ] unless defined? NET_HTTP_EXCEPTIONS
+
+    attr_accessor :config, :scheme, :host, :port, :max_redirects, :ssl,
+                  :user_agent, :accept, :max_redirects, :headers, :uri
+
+    def self.default_options
+      {
+        :headers => {
+          'Accept'     => 'application/json',
+          'User-Agent' => "Yammer Ruby Gem #{Yammer::Version}"
+        },
+        :ssl => {:verify => true},
+        :max_redirects => 5
+      }
+    end
+
+    def initialize(url, options={})
+      @uri = Addressable::URI.parse(url)
+      self.class.default_options.keys.each do |key|
+        instance_variable_set(:"@#{key}", options.fetch(key, self.class.default_options[key]))
+      end
+    end
+
+    def default_headers
+      self.class.default_options[:headers]
+    end
+
+    def scheme=(scheme)
+      unless ['http', 'https'].include? scheme
+        raise UnsupportedSchemeError.new "#{scheme} is not supported, only http and https"
+      end
+      @scheme = scheme
+    end
+
+    def scheme
+      @scheme ||= @uri.scheme
+    end
+
+    def host
+      @host ||= @uri.host
+    end
+
+    def port
+      _port = ssl? ? 443 : 80
+      @port = @uri.port || _port
+    end
+
+    def absolute_url(path='')
+      "#{scheme}://#{host}#{path}"
+    end
+
+    def ssl?
+      scheme == "https" ? true : false
+    end
+
+    def ssl=(opts)
+      raise "Expected Hash but got #{opts.class.name}" unless opts.is_a?(Hash)
+      @ssl.merge!(opts)
+    end
+
+    def http_connection(opts={})
+      _host   = opts[:host]   || host
+      _port   = opts[:port]   || port
+      _scheme = opts[:scheme] || scheme
+
+      @http_client = Net::HTTP.new(_host, _port)
+
+      configure_ssl(@http_client) if _scheme == 'https'
+
+      @http_client
+    end
+
+    def send_request(method, path, opts={})
+      headers         = @headers.merge(opts.fetch(:headers, {}))
+      params          = opts[:params] || {}
+      query           = Addressable::URI.form_encode(params)
+      method          = method.to_sym
+      normalized_path = query.empty? ? path : [path, query].join("?")
+      client          = http_connection(opts.fetch(:connection_options, {}))
+
+      if (method == :post || method == :put)
+        headers['Content-Type'] ||= 'application/x-www-form-urlencoded'
+      end
+
+      case method
+      when :get, :delete
+        response = client.send(method, normalized_path, headers)
+      when :post, :put
+        response = client.send(method, path, query, headers)
+      else
+        raise UnhandledHTTPMethodError.new("Unsupported HTTP method, #{method}")
+      end
+
+      status = response.code.to_i
+
+      case status
+      when 301, 302, 303, 307
+        unless redirect_limit_reached?
+          if status == 303
+            method = :get
+            params = nil
+            headers.delete('Content-Type')
+          end
+          redirect_uri = Addressable::URI.parse(response.header['Location'])
+          conn = {
+            :scheme => redirect_uri.scheme,
+            :host   => redirect_uri.host,
+            :port   => redirect_uri.port
+          }
+          return send_request(method, redirect_uri.path, :params => params, :headers => headers, :connection_options => conn)
+        end
+      when 100..599
+        @redirect_count = 0
+      else
+        raise "Unhandled status code value of #{response.code}"
+      end
+      response
+    rescue *NET_HTTP_EXCEPTIONS
+      raise "Error::ConnectionFailed, #{$!.backtrace}"
+    end
+
+  private
+
+    def configure_ssl(http)
+      http.use_ssl      = true
+      http.verify_mode  = ssl_verify_mode
+      http.cert_store   = ssl_cert_store
+
+      http.cert         = ssl[:client_cert]  if ssl[:client_cert]
+      http.key          = ssl[:client_key]   if ssl[:client_key]
+      http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
+      http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
+      http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
+      http.ssl_version  = ssl[:version]      if ssl[:version]
+    end
+
+    def ssl_verify_mode
+      if ssl.fetch(:verify, true)
+          OpenSSL::SSL::VERIFY_PEER
+      else
+          OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    def ssl_cert_store
+      return ssl[:cert_store] if ssl[:cert_store]
+      cert_store = OpenSSL::X509::Store.new
+      cert_store.set_default_paths
+      cert_store
+    end
+
+    def redirect_limit_reached?
+      @redirect_count ||= 0
+      @redirect_count += 1
+      @redirect_count > @max_redirects
+    end
+  end
+end

data/lib/yammer/identity_map.rb

@@ -0,0 +1,42 @@
+module Yammer
+  class IdentityMap
+
+    class InvalidKeyError < StandardError; end
+
+    def initialize
+      @map  = {}
+      @size = 0
+    end
+
+    # @note retrives key from identity map
+    # @return [Hash]
+    # @param key [string] 
+    # @param default [Hash]
+    def get(key, default=nil)
+      @map["#{key}"] || default
+    end
+
+    # @note inserts a hash of attributes into identity map
+    # @return [Hash]
+    # @param key [string] 
+    # @param value [Hash]
+    def put(key, value)
+      if key.nil? || key.empty?
+        raise InvalidKeyError.new
+      end
+      @map["#{key}"] = value
+    end
+
+    # @note returns the current size of identity map
+    # @return [Integer]
+    def size
+      @map.keys.count
+    end
+
+    # clears the entire identity map
+    # @return [Hash]
+    def purge!
+      @map = {}
+    end
+  end
+end

data/lib/yammer/model.rb

@@ -0,0 +1,6 @@
+require 'yammer/model/base'
+require 'yammer/model/user'
+require 'yammer/model/group'
+require 'yammer/model/group_membership'
+require 'yammer/model/message'
+require 'yammer/model/thread'