linked_in 0.0.21

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2009-10-25
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,27 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+docs/sample-oauth-plugin_token.rb
+lib/linked_in.rb
+lib/linked_in/base.rb
+lib/linked_in/oauth.rb
+lib/linked_in/request.rb
+linked_in.gemspec
+script/console
+script/destroy
+script/generate
+spec/fixtures/connections.xml
+spec/fixtures/connections_with_field_selectors.xml
+spec/fixtures/empty.xml
+spec/fixtures/error.xml
+spec/fixtures/network.xml
+spec/fixtures/people.xml
+spec/fixtures/profile.xml
+spec/linked_in/base_spec.rb
+spec/linked_in/oauth_spec.rb
+spec/linked_in/request_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/README.rdoc

@@ -0,0 +1,104 @@
+== DESCRIPTION:
+
+The linked_in gem wraps the LinkedIn API making it easy to read and write profile information and messages on http://linkedin.com. Full support for OAuth is provided including a wrapper for Pelle's oauth-plugin (http://github.com/pelle/oauth-plugin/). This gem borrowed heavily from junemakers twitter gem (http://github.com/jnunemaker/twitter/). 
+
+== EXAMPLES:
+	
+First, authorize via oauth:
+
+	oauth = LinkedIn::OAuth.new('token', 'secret') # => #<LinkedIn::OAuth:0x1021db048 ...> 
+	
+	oauth.request_token.authorize_url # => "https://api.linked_in.com/uas/oauth/authorize?oauth_token=XXXX" 
+	
+Visit authorization URL, authorize and copy PIN
+	
+	oauth.authorize_from_request(oauth.request_token.token, oauth.request_token.secret, PIN)
+
+Finally, do stuff!
+
+	linked_in = LinkedIn::Base.new(oauth)
+
+=== Profile Information
+
+	# currently auth'd users basic profile
+	linked_in.profile
+	
+	# currently auth'd users full profile
+	linked_in.profile(:my, :full)
+	
+	# current auth'd users profile, with field selectors
+	linked_in.profile(:my, ['first-name', 'last-name'])
+
+	# get a profile by public URL
+	linked_in.profile(:url => 'http://www.linkedin.com/pub/peter-brown/0/116/112')
+	
+	# get a profile by ID
+	linked_in.profile(:id => '12345')
+	
+	# get full profile by ID
+	linked_in.profile({:id => '12123'}, :full)
+
+	# get profile by ID with field selectors
+	linked_in.profile({:id => '12123'}, ('first-name', 'last-name'))
+
+=== Connection Information
+
+	# currently auth'd users connections
+	linked_in.connections
+
+=== Network Updates
+
+	# currently auth'd users network updates
+	linked_in.network
+		
+	# limit updates 
+	linked_in.network(:start => 0, :count => 20)
+
+== REQUIREMENTS:
+
+A few gems are required:
+
+* forwardable
+* oauth
+* xml-object
+
+You'll also need a LinkedIn API account, which you can get here:
+
+* http://developer.linked_in.com/community/apis
+
+== INSTALL:
+
+	sudo gem install gemcutter
+	gem tumble
+	sudo gem install linked_in
+
+== TODO:
+
+* add support for messaging between connections (http://developer.linked_in.com/docs/DOC-1044)
+* add support for get network updates (http://developer.linked_in.com/docs/DOC-1006)
+* add support for search API (http://developer.linked_in.com/docs/DOC-1005)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe' #, '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/linked_in'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'linked_in' do
+  self.developer 'Peter T. Brown', 'peter@pathable.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/docs/sample-oauth-plugin_token.rb

@@ -0,0 +1,18 @@
+require 'linked_in'
+require 'oauth/models/consumers/token'
+
+class ConsumerToken < ActiveRecord::Base
+  include Oauth::Models::Consumers::Token  
+end
+
+class LinkedInToken < ConsumerToken  
+  def client
+    unless @client
+      @linkedin_oauth = LinkedIn::OAuth.new(LinkedInToken.consumer.key, LinkedInToken.consumer.secret)
+      @linkedin_oauth.authorize_from_access(token,secret)
+      @client = LinkedIn::Base.new(@linkedin_oauth)
+    end
+    
+    @client
+  end
+end

data/lib/linked_in.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'forwardable'
+gem 'oauth', '>= 0.3.5'
+require 'oauth'
+gem 'jordi-xml-object', '>= 0.9.91'
+require 'xml-object'                  
+
+
+
+module LinkedIn
+  VERSION = '0.0.21'
+  
+  class LinkedInError < StandardError; end  
+  class Unauthorized  < LinkedInError; end
+  class General       < LinkedInError; end
+  class Unavailable   < StandardError; end
+  class NotFound      < StandardError; end  
+  class Forbidden     < StandardError; end  
+  
+  autoload :Base, File.join(File.dirname(__FILE__), *%w[linked_in base.rb])
+  autoload :OAuth, File.join(File.dirname(__FILE__), *%w[linked_in oauth.rb])
+  autoload :Request, File.join(File.dirname(__FILE__), *%w[linked_in request.rb])
+end
+

data/lib/linked_in/base.rb

@@ -0,0 +1,84 @@
+module LinkedIn
+  class Base
+    API_VERSION = 'v1'
+    extend Forwardable
+    
+    def_delegators :client, :get, :post, :put
+    
+    attr_reader :client
+    
+    def initialize(client)
+      @client = client
+    end
+    
+    # Lookup Options: url=<public profile URL>, id=<member id>
+    # Field Options: :full
+    def profile(lookup = nil, fields = nil, query = {})
+      path = profile_path(nil, lookup, fields)
+      perform_get(path, :query => query)
+    end    
+    
+    # Query options: start=N, count=N
+    def people(query = {})
+      path = api_path('people')
+      perform_get(path, query)
+    end
+    
+    # Query options: start=N, count=N
+    def connections(lookup = nil, fields = nil, query = {})
+      path = profile_path('connections', lookup, fields)
+      perform_get(path, :query => query)
+    end
+    
+    def network(query = {})
+      path = profile_path('network')
+      perform_get(path, :query => query)
+    end
+    
+    def current_status(update)
+      path = profile_path('current-status')
+      update_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><current-status>#{update}</current-status>"
+      perform_put(path, :body => update_xml)
+    end
+    
+    # update is something like: '&lt;a href=&quot;http://www.linkedin.com/profile?viewProfile=&amp;key=ABCDEFG&quot;&gt;Richard Brautigan&lt;/a&gt; is reading about&lt;a href=&quot;http://www.tigers.com&quot;&gt;Tigers&lt;/a&gt;http://www.tigers.com&gt;Tigers&lt;/a&gt;.'}
+    def person_activities(update, timestamp = nil)
+      path = profile_path('person-activities')
+      body = {'activity' => {
+        'timestamp' => (timestamp || Time.now.to_i),
+        'content-type' => 'linkedin-html', 
+        'body' => update}
+      }
+      perform_post(path, body)
+    end
+    
+    
+    private
+    
+    def api_path(p)
+      "/#{API_VERSION}/#{p}"
+    end
+    
+    # Generate LinkedIn API compatable paths
+    def profile_path(api = nil, lookup = nil, fields = nil)
+      path =  api_path('people') + '/'
+      path += lookup.kind_of?(Hash) ? "#{lookup.first[0]}=#{lookup.first[1]}" : ([nil, :my].include?(lookup) ? '~' : lookup.to_s)
+      path += api.nil? ? '' : "/#{api}"
+      path += fields.kind_of?(Array) ? ":(#{fields.collect{|f| f.to_s}.join(',')})" : (fields.nil? ? '' : ":#{fields.to_s}")
+      path
+    end
+
+    def perform_get(path, options={})
+      LinkedIn::Request.get(self, path, options)
+    end
+    
+    def perform_post(path, options={})
+      LinkedIn::Request.post(self, path, options)
+    end
+
+    def perform_put(path, options={})
+      LinkedIn::Request.put(self, path, options)
+    end
+  
+  end
+end

data/lib/linked_in/oauth.rb

@@ -0,0 +1,65 @@
+module LinkedIn
+  # >> oauth = LinkedIn::OAuth.new('token', 'secret')
+  # => #<LinkedIn::OAuth:0x1021db048 ...> 
+  # >> oauth.request_token.authorize_url 
+  # => "https://api.linkedin.com/uas/oauth/authorize?oauth_token=XXXX" # goto URL
+  # >> oauth.authorize_from_request(oauth.request_token.token, oauth.request_token.secret, PIN)
+  # DONE    
+  class OAuth    
+    extend Forwardable
+    
+    SITE_URL = 'https://api.linkedin.com'
+    
+    def_delegators :access_token, :get, :post, :put
+    
+    attr_reader :ctoken, :csecret, :consumer_options
+    
+    # Options
+    def initialize(ctoken, csecret, options={})
+      @ctoken = ctoken
+      @csecret = csecret
+      @consumer_options = {
+        :request_token_path => "/uas/oauth/requestToken?oauth_callback=oob",
+        :access_token_path  => "/uas/oauth/accessToken",
+        :authorize_path     => "/uas/oauth/authorize"
+      }.merge(options)
+    end
+    
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, {:site => SITE_URL}.merge(consumer_options))
+    end
+    
+    def set_callback_url(url)
+      clear_request_token
+      request_token(:oauth_callback => url)
+    end
+    
+    # Note: If using oauth with a web app, be sure to provide :oauth_callback.
+    # Options:
+    #   :oauth_callback => String, url that linkedin should redirect to
+    def request_token(options={})
+      @request_token ||= consumer.get_request_token(options)
+    end
+    
+    # For web apps use params[:oauth_verifier], for desktop apps,
+    # use the verifier is the pin that twitter gives users.
+    def authorize_from_request(rtoken, rsecret, verifier_or_pin)
+      request_token = ::OAuth::RequestToken.new(consumer, rtoken, rsecret)
+      access_token = request_token.get_access_token(:oauth_verifier => verifier_or_pin)
+      @atoken, @asecret = access_token.token, access_token.secret
+    end
+    
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+    
+    def authorize_from_access(atoken, asecret)
+      @atoken, @asecret = atoken, asecret
+    end
+    
+    private
+      def clear_request_token
+        @request_token = nil
+      end
+  end
+end

data/lib/linked_in/request.rb

@@ -0,0 +1,86 @@
+module LinkedIn
+  class Request
+     extend Forwardable
+    
+    def self.get(client, path, options = {})
+      new(client, :get, path, options).perform
+    end
+    
+    def self.post(client, path, options = {})
+      new(client, :post, path, options).perform
+    end
+    
+    def self.put(client, path, options = {})
+      new(client, :put, path, options).perform
+    end
+    
+    attr_reader :client, :method, :path, :options
+    
+    def_delegators :client, :get, :post, :put
+    
+    def initialize(client, method, path, options={})
+      @client, @method, @path, @options = client, method, path, {:mash => true}.merge(options)
+    end
+    
+    def uri
+      @uri ||= begin
+        uri = URI.parse(path)
+        
+        if options[:query] && options[:query] != {}
+          uri.query = to_query(options[:query])
+        end
+        
+        uri.to_s
+      end
+    end
+    
+    def perform
+      make_friendly(send("perform_#{method}"))
+    end
+    
+    private
+      def perform_get
+        send(:get, uri, options[:headers])
+      end
+      
+      def perform_post
+        send(:post, uri, options[:body], options[:headers])
+      end
+      
+      def perform_put
+        send(:put, uri, options[:body], options[:headers])
+      end
+      
+      def make_friendly(response)
+        raise_errors(response)
+        parse(response)        
+      end
+            
+      def raise_errors(response)
+        case response.code.to_i
+        when 401 # NotAuthorized
+          raise Unauthorized.new, "#{response.code}: #{response.message}"
+        when 403 # Forbidden
+          raise Forbidden.new, "#{response.code}: #{response.message}"
+        when 404 # NotFound
+          raise NotFound, "#{response.code}: #{response.message}"
+        when 500 # InternalServerError
+          raise Unavailable, "LinkedIn had an internal error #{response.code}: #{response.message}"
+        when 502..503 # Unavailable, BadGateway
+          raise Unavailable, "#{response.code}: #{response.message}"
+        end
+      end
+      
+      def parse(response)
+        return if response.nil? || response.body.blank?
+        XMLObject.new(response.body)
+      end
+      
+      def to_query(options)
+        options.inject([]) do |collection, opt| 
+          collection << "#{opt[0]}=#{opt[1]}"
+          collection
+        end * '&'
+      end
+  end
+end