pmoran-yammer4r 0.1.5

data/README

@@ -0,0 +1,16 @@
+= Yammer4R
+
+== Developers
+* {Jim Patterson} <jimp79 at gmail dot com>
+
+== Description
+Yammer4R provides an object based API to query or update your Yammer account via pure Ruby.  It hides the ugly HTTP/REST code from your code.
+
+== External Dependencies
+* Ruby 1.8 (tested with 1.8.7)
+* JSON gem (tested with versions: 1.1.3)
+* OAuth gem (tested with versions: 0.2.7)
+* RSpec gem (tested with versions: 1.1.11)
+
+== Usage Examples
+Coming soon...

data/Rakefile

@@ -0,0 +1,13 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+ 
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+require 'yammer4r'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*spec.rb']
+end
+
+task :default => [:spec]

data/TODO

@@ -0,0 +1,2 @@
+Test! There are currently no tests for yammer4r, and that makes me very sad.
+Switch to HTTParty instead of yammer_request.  

data/bin/yammer_create_oauth_yml.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Instructions:
+#
+# Register your application at https://www.yammer.com/client_applications/new
+# Upon successful registration, you'll recieve your consumer key and secret.
+# Pass these values on the command line as --key (-k) and --secret (-s) then
+# follow the instructions.
+
+require 'optparse'
+require 'rubygems'
+require 'oauth'
+
+OPTIONS = {
+  :outfile  => 'oauth.yml'
+}
+
+YAMMER_OAUTH = "https://www.yammer.com" 
+
+ARGV.options do |o|
+  script_name = File.basename($0)
+  
+  o.set_summary_indent('  ')
+  o.banner =    "Usage: #{script_name} [OPTIONS]"
+  o.define_head "Create a yaml file for yammer oauth"
+  o.separator   ""
+  o.separator   "[-k] and [-s] options are mandatory"
+  o.separator   ""
+  
+  o.on("-o", "--outfile=[val]", String,
+       "Yaml output file",
+       "Default: #{OPTIONS[:outfile]}")     { |OPTIONS[:outfile]| }
+  o.on("-k", "--key=val", String,
+       "Consumer key for Yammer app")       { |key| OPTIONS[:key] = key}
+  o.on("-s", "--secret=val", String,
+       "Consumer secret for Yammer app")    { |secret| OPTIONS[:secret] = secret}
+  
+  o.separator ""
+
+  o.on_tail("-h", "--help", "Show this help message.") { puts o; exit }
+  o.parse!
+end
+
+unless OPTIONS[:key] && OPTIONS[:secret]
+  raise ArgumentError, "Must supply consumer key and secret (use -h for help)"
+end
+
+consumer      = OAuth::Consumer.new OPTIONS[:key], OPTIONS[:secret], {:site => YAMMER_OAUTH}
+request_token = consumer.get_request_token
+
+puts "Please visit the following URL in your browser to authorize your application, then enter the 4 character security code when done: #{request_token.authorize_url}"
+oauth_verifier =  gets
+response = consumer.token_request(consumer.http_method, 
+                                  (consumer.access_token_url? ? consumer.access_token_url : consumer.access_token_path),
+                                  request_token, 
+                                  {}, 
+                                  :oauth_verifier =>  oauth_verifier.chomp)
+access_token = OAuth::AccessToken.new(consumer,response[:oauth_token],response[:oauth_token_secret])
+
+oauth_yml = <<-EOT
+consumer:
+  key: #{OPTIONS[:key]}
+  secret: #{OPTIONS[:secret]}
+access:
+  token: #{access_token.token}
+  secret: #{access_token.secret}
+EOT
+
+File.open(OPTIONS[:outfile], "w") do |f|
+  f.write oauth_yml
+end

data/example.rb

@@ -0,0 +1,15 @@
+require 'yammer4r'
+
+config_path = File.dirname(__FILE__) + 'oauth.yml'
+yammer = Yammer::Client.new(:config => config_path)
+
+# Get all messages
+messages = yammer.messages
+puts messages.size
+puts messages.last.body.plain
+puts messages.last.body.parsed
+
+# Print out all the users
+yammer.users.each do |u|
+  puts "#{u.name} - #{u.me?}"
+end

data/lib/ext/core_ext.rb

@@ -0,0 +1,30 @@
+class String
+  def to_boolean
+    case self
+    when 'true'
+      true
+    when 'false'
+      false
+    else
+      nil
+    end
+  end
+end
+
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  def assert_has_keys(*valid_keys)
+    missing_keys = [valid_keys].flatten - keys
+    raise(ArgumentError, "Missing Option(s): #{missing_keys.join(", ")}") unless missing_keys.empty?
+  end
+end

data/lib/yammer/client.rb

@@ -0,0 +1,100 @@
+module Yammer
+  class Client
+    def initialize(options={})
+      options.assert_has_keys(:consumer, :access) unless options.has_key?(:config)
+      
+      yammer_url = options.delete(:yammer_host) || "https://www.yammer.com"
+      @api_path   = "/api/v1/"
+
+      if options[:config]
+        config              = YAML.load(open(options[:config]))
+        options[:consumer]  = config['consumer'].symbolize_keys
+        options[:access]    = config['access'].symbolize_keys
+      end
+
+      consumer = OAuth::Consumer.new(options[:consumer][:key], options[:consumer][:secret], :site => yammer_url)
+      consumer.http.set_debug_output($stderr) if options[:verbose] == true
+      @access_token = OAuth::AccessToken.new(consumer, options[:access][:token], options[:access][:secret])
+    end
+
+
+    # TODO: modularize message and user handling 
+    def messages(action = :all, params = {})
+      params.merge!(:resource => :messages)
+      params.merge!(:action => action) unless action == :all
+
+      parsed_response = JSON.parse(yammer_request(:get, params).body)
+      older_available = parsed_response['meta']['older_available']
+
+      ml = parsed_response['messages'].map do |m|
+         mash(m)
+      end
+      Yammer::MessageList.new(ml, older_available, self)
+    end
+
+    # POST or DELETE a message
+    def message(action, params)
+      params.merge!(:resource => :messages)
+      yammer_request(action, params)
+    end
+
+    def users(params = {})
+      params.merge!(:resource => :users)
+      JSON.parse(yammer_request(:get, params).body).map { |u| Yammer::User.new(mash(u), self) }
+    end
+
+    def user(id)
+      u = JSON.parse(yammer_request(:get, {:resource => :users, :id => id}).body)
+      Yammer::User.new(mash(u), self)
+    end
+
+    def current_user
+      u = JSON.parse(yammer_request(:get, {:resource => :users, :action => :current}).body)
+      Yammer::User.new(mash(u), self)
+    end
+    alias_method :me, :current_user
+
+    private
+
+    def yammer_request(http_method, options)
+      request_uri = @api_path + options.delete(:resource).to_s
+      [:action, :id].each {|k| request_uri += "/#{options.delete(k)}" if options.has_key?(k) }
+      request_uri += ".json"
+
+      if options.any?
+        request_uri += "?#{create_query_string(options)}" unless http_method == :post
+      end
+
+      if http_method == :post
+        handle_response(@access_token.send(http_method, request_uri, options))
+      else
+        handle_response(@access_token.send(http_method, request_uri))
+      end
+    end
+
+    def create_query_string(options)
+      options.map {|k, v| "#{OAuth::Helper.escape(k)}=#{OAuth::Helper.escape(v)}"}.join('&')
+    end
+
+    def mash(json)
+      Mash.new(json)
+    end
+
+    def handle_response(response)
+      # TODO: Write classes for exceptions
+      case response.code.to_i
+        when 200..201
+          response
+        when 400
+          raise "400 Bad request"
+        when 401
+          raise  "Authentication failed. Check your username and password"
+        when 503
+          raise "503: Service Unavailable"
+        else
+          raise "Error. HTTP Response #{response.code}"
+        end   
+    end
+
+  end
+end

data/lib/yammer/message.rb

@@ -0,0 +1,26 @@
+class Yammer::Message
+  
+  attr_reader :id, :url, :web_url, :replied_to_id, :thread_id,
+              :body_plain, :body_parsed, :message_type, :client_type,
+              :sender_id, :sender_type
+  
+  def initialize(m)
+    @id = m['id']
+    @url = m['url']
+    @web_url = m['web_url']
+    @replied_to_id = m['replied_to_id']
+    @thread_id = m['thread_id']
+    @body_plain = m['body']['plain']
+    @body_parsed = m['body']['parsed']
+    @message_type = m['message_type']
+    @client_type = m['client_type']
+    @sender_id = m['sender_id']
+    @sender_type = m['sender_type']
+    begin
+      @created_at = m['created_at']
+    rescue ArgumentError => e
+      @created_at = nil
+    end
+  end
+  
+end

data/lib/yammer/message_list.rb

@@ -0,0 +1,20 @@
+class Yammer::MessageList < Array
+  
+  attr_reader :older_available, :ids
+  
+  def initialize(a, oa, c)
+    super(a)
+    @older_available = oa
+    @client = c
+    @ids = a.map {|m| m.id}.sort
+  end
+  
+  def first
+    self[0]
+  end
+  
+  def last
+    self[self.size - 1]
+  end
+  
+end

data/lib/yammer/user.rb

@@ -0,0 +1,17 @@
+class Yammer::User
+  extend Forwardable 
+  def_delegator :@user, :id
+
+  def initialize(mash, client)
+    @user   = mash
+    @client = client 
+  end
+
+  def me?
+    @user.id == @client.me.id
+  end
+
+  def method_missing(call, *args)
+    @user.send(call, *args)
+  end
+end

data/lib/yammer4r.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+require 'rubygems'
+require 'date'
+require 'yaml'
+require 'open-uri'
+
+gem 'json', '>= 1.1.7'
+require 'json'
+
+gem 'oauth', '>=0.3.5'
+require 'oauth'
+
+gem 'mash', '>=0.0.3'
+require 'mash'
+
+$:.unshift(File.dirname(__FILE__))
+require 'ext/core_ext'
+require 'yammer/client'
+require 'yammer/message'
+require 'yammer/message_list'
+require 'yammer/user'

data/oauth.yml.template

@@ -0,0 +1,7 @@
+consumer:
+  key: CLIENT_KEY
+  secret: CLIENT_SECRET
+  
+access:
+  token: CONSUMER_TOKEN
+  secret: CONSUMER_SECRET

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'yammer4r'
+require 'spec'

data/spec/yammer/client_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'ostruct'
+
+describe Yammer::Client do
+  
+  context "creating" do
+  
+    before(:each) do
+      mock_consumer = mock(OAuth::Consumer)
+      OAuth::Consumer.stub!("new").and_return(mock_consumer)
+      @mock_http = mock("http")
+      mock_consumer.stub!("http").and_return(@mock_http)
+    end
+  
+    it "can be configured to be verbose" do
+      @mock_http.should_receive("set_debug_output").with($stderr)
+      Yammer::Client.new(:consumer => {}, :access => {}, :verbose => true)
+    end
+
+    it "should not be configured to be verbose unless asked to be" do
+      @mock_http.should_not_receive("set_debug_output")
+      Yammer::Client.new(:consumer => {}, :access => {})
+    end
+
+    it "should not be configured to be verbose if asked not to be" do
+      @mock_http.should_not_receive("set_debug_output")
+      Yammer::Client.new(:consumer => {}, :access => {}, :verbose => false)
+    end
+
+  end  
+  
+  context "users" do
+    
+    before(:each) do
+      @mock_access_token = mock(OAuth::AccessToken)
+      @response = OpenStruct.new(:code => 200, :body => '{}')
+      OAuth::AccessToken.stub!("new").and_return(@mock_access_token)
+      @client = Yammer::Client.new(:consumer => {}, :access => {})
+    end
+    
+    it "should request the first page by default" do
+      @mock_access_token.should_receive("get").with("/api/v1/users.json").and_return(@response)
+      @client.users
+    end
+    
+    it "can request a specified page" do
+      @mock_access_token.should_receive("get").with("/api/v1/users.json?page=2").and_return(@response)
+      @client.users(:page => 2)
+    end
+    
+  end  
+  
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: pmoran-yammer4r
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Jim Patterson
+- Jason Stewart
+- Peter Moran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-29 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mash
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.5
+    version: 
+description: Yammer4R provides an object based API to query or update your Yammer account via pure Ruby.  It hides the ugly HTTP/REST code from your code.
+email: workingpeter@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- example.rb
+- Rakefile
+- TODO
+- oauth.yml.template
+- bin/yammer_create_oauth_yml.rb
+- spec/spec_helper.rb
+- spec/yammer/client_spec.rb
+- lib/ext/core_ext.rb
+- lib/yammer/client.rb
+- lib/yammer/message.rb
+- lib/yammer/message_list.rb
+- lib/yammer/user.rb
+- lib/yammer4r.rb
+has_rdoc: true
+homepage: http://github.com/pmoran/yammer4r
+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: 2
+summary: Yammer access for ruby
+test_files: []
+