linkedin-drspin 0.3.6

data/lib/linked_in/helpers/authorization.rb

@@ -0,0 +1,68 @@
+module LinkedIn
+  module Helpers
+
+    module Authorization
+
+      DEFAULT_OAUTH_OPTIONS = {
+        :request_token_path => "/uas/oauth/requestToken",
+        :access_token_path  => "/uas/oauth/accessToken",
+        :authorize_path     => "/uas/oauth/authorize",
+        :api_host           => "https://api.linkedin.com",
+        :auth_host          => "https://www.linkedin.com"
+      }
+
+      def consumer
+        @consumer ||= ::OAuth::Consumer.new(@consumer_token, @consumer_secret, parse_oauth_options)
+      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 LinkedIn gives users.
+      def authorize_from_request(request_token, request_secret, verifier_or_pin)
+        request_token = ::OAuth::RequestToken.new(consumer, request_token, request_secret)
+        access_token  = request_token.get_access_token(:oauth_verifier => verifier_or_pin)
+        @auth_token, @auth_secret = access_token.token, access_token.secret
+      end
+
+      def access_token
+        @access_token ||= ::OAuth::AccessToken.new(consumer, @auth_token, @auth_secret)
+      end
+
+      def authorize_from_access(atoken, asecret)
+        @auth_token, @auth_secret = atoken, asecret
+      end
+
+      private
+
+        # since LinkedIn uses api.linkedin.com for request and access token exchanges,
+        # but www.linkedin.com for authorize/authenticate, we have to take care
+        # of the url creation ourselves.
+        def parse_oauth_options
+          {
+            :request_token_url => full_oauth_url_for(:request_token, :api_host),
+            :access_token_url  => full_oauth_url_for(:access_token,  :api_host),
+            :authorize_url     => full_oauth_url_for(:authorize,     :auth_host),
+            :site              => @consumer_options[:site] || @consumer_options[:api_host] || DEFAULT_OAUTH_OPTIONS[:api_host]
+          }
+        end
+
+        def full_oauth_url_for(url_type, host_type)
+          if @consumer_options["#{url_type}_url".to_sym]
+            @consumer_options["#{url_type}_url".to_sym]
+          else
+            host = @consumer_options[:site] || @consumer_options[host_type] || DEFAULT_OAUTH_OPTIONS[host_type]
+            path = @consumer_options[:"#{url_type}_path".to_sym] || DEFAULT_OAUTH_OPTIONS["#{url_type}_path".to_sym]
+            "#{host}#{path}"
+          end
+        end
+
+    end
+
+  end
+end

data/lib/linked_in/helpers/request.rb

@@ -0,0 +1,80 @@
+module LinkedIn
+  module Helpers
+
+    module Request
+
+      DEFAULT_HEADERS = {
+        'x-li-format' => 'json'
+      }
+
+      API_PATH = '/v1'
+
+      protected
+
+        def get(path, options={})
+          response = access_token.get("#{API_PATH}#{path}", DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response.body
+        end
+
+        def post(path, body='', options={})
+          response = access_token.post("#{API_PATH}#{path}", body, DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+        def put(path, body, options={})
+          response = access_token.put("#{API_PATH}#{path}", body, DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+        def delete(path, options={})
+          response = access_token.delete("#{API_PATH}#{path}", DEFAULT_HEADERS.merge(options))
+          raise_errors(response)
+          response
+        end
+
+      private
+
+        def raise_errors(response)
+          # Even if the json answer contains the HTTP status code, LinkedIn also sets this code
+          # in the HTTP answer (thankfully).
+          case response.code.to_i
+          when 401
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::UnauthorizedError.new(data), "(#{data.status}): #{data.message}"
+          when 400
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::GeneralError.new(data), "(#{data.status}): #{data.message}"
+          when 403
+            data = Mash.from_json(response.body)
+            raise LinkedIn::Errors::AccessDeniedError.new(data), "(#{data.status}): #{data.message}"
+          when 404
+            raise LinkedIn::Errors::NotFoundError, "(#{response.code}): #{response.message}"
+          when 500
+            raise LinkedIn::Errors::InformLinkedInError, "LinkedIn had an internal error. Please let them know in the forum. (#{response.code}): #{response.message}"
+          when 502..503
+            raise LinkedIn::Errors::UnavailableError, "(#{response.code}): #{response.message}"
+          end
+        end
+
+        def to_query(options)
+          options.inject([]) do |collection, opt|
+            collection << "#{opt[0]}=#{opt[1]}"
+            collection
+          end * '&'
+        end
+
+        def to_uri(path, options)
+          uri = URI.parse(path)
+
+          if options && options != {}
+            uri.query = to_query(options)
+          end
+          uri.to_s
+        end
+    end
+
+  end
+end

data/lib/linked_in/mash.rb

@@ -0,0 +1,68 @@
+require 'hashie'
+require 'multi_json'
+
+module LinkedIn
+  class Mash < ::Hashie::Mash
+
+    # a simple helper to convert a json string to a Mash
+    def self.from_json(json_string)
+      result_hash = ::MultiJson.decode(json_string)
+      new(result_hash)
+    end
+
+    # returns a Date if we have year, month and day, and no conflicting key
+    def to_date
+      if !self.has_key?('to_date') && contains_date_fields?
+        Date.civil(self.year, self.month, self.day)
+      else
+        super
+      end
+    end
+
+    def timestamp
+      value = self['timestamp']
+      if value.kind_of? Integer
+        value = value / 1000 if value > 9999999999
+        Time.at(value)
+      else
+        value
+      end
+    end
+
+    protected
+
+      def contains_date_fields?
+        self.year? && self.month? && self.day?
+      end
+
+      # overload the convert_key mash method so that the LinkedIn
+      # keys are made a little more ruby-ish
+      def convert_key(key)
+        case key.to_s
+        when '_key'
+          'id'
+        when '_total'
+          'total'
+        when 'values'
+          'all'
+        when 'numResults'
+          'total_results'
+        else
+          underscore(key)
+        end
+      end
+
+      # borrowed from ActiveSupport
+      # no need require an entire lib when we only need one method
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+  end
+end

data/lib/linked_in/search.rb

@@ -0,0 +1,56 @@
+module LinkedIn
+
+  module Search
+    def search(options={}, type='people')
+
+      path = "/#{type.to_s}-search"
+
+      if options.is_a?(Hash)
+        fields = options.delete(:fields)
+        path += field_selector(fields) if fields
+      end
+
+      options = { :keywords => options } if options.is_a?(String)
+      options = format_options_for_query(options)
+
+      result_json = get(to_uri(path, options))
+
+      Mash.from_json(result_json)
+    end
+
+    private
+
+      def format_options_for_query(opts)
+        opts.inject({}) do |list, kv|
+          key, value = kv.first.to_s.gsub("_","-"), kv.last
+          list[key]  = sanitize_value(value)
+          list
+        end
+      end
+
+      def sanitize_value(value)
+        value = value.join("+") if value.is_a?(Array)
+        value = value.gsub(" ", "+") if value.is_a?(String)
+        value
+      end
+
+      def field_selector(fields)
+        result = ":("
+        fields = fields.to_a.map do |field|
+          if field.is_a?(Hash)
+            innerFields = []
+            field.each do |key, value|
+              innerFields << key.to_s.gsub("_","-") + field_selector(value)
+            end
+            innerFields.join(',')
+          else
+            field.to_s.gsub("_","-")
+          end
+        end
+        result += fields.join(',')
+        result += ")"
+        result
+      end
+  end
+
+end

data/lib/linked_in/version.rb

@@ -0,0 +1,11 @@
+module LinkedIn
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 6
+    PRE   = nil
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+  end
+
+end

data/lib/linkedin.rb

@@ -0,0 +1,32 @@
+require 'oauth'
+
+module LinkedIn
+
+  class << self
+    attr_accessor :token, :secret, :default_profile_fields
+
+    # config/initializers/linkedin.rb (for instance)
+    #
+    # LinkedIn.configure do |config|
+    #   config.token = 'consumer_token'
+    #   config.secret = 'consumer_secret'
+    #   config.default_profile_fields = ['education', 'positions']
+    # end
+    #
+    # elsewhere
+    #
+    # client = LinkedIn::Client.new
+    def configure
+      yield self
+      true
+    end
+  end
+
+  autoload :Api,     "linked_in/api"
+  autoload :Client,  "linked_in/client"
+  autoload :Mash,    "linked_in/mash"
+  autoload :Errors,  "linked_in/errors"
+  autoload :Helpers, "linked_in/helpers"
+  autoload :Search,  "linked_in/search"
+  autoload :Version, "linked_in/version"
+end

data/linkedin.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path('../lib/linked_in/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.add_dependency 'hashie', '~> 1.2.0'
+  gem.add_dependency 'multi_json', '~> 1.0.3'
+  gem.add_dependency 'oauth', '~> 0.4.5'
+  gem.add_development_dependency 'json', '~> 1.6'
+  gem.add_development_dependency 'rake', '~> 0.9'
+  gem.add_development_dependency 'rdoc', '~> 3.8'
+  gem.add_development_dependency 'rspec', '~> 2.6'
+  gem.add_development_dependency 'simplecov', '~> 0.5'
+  gem.add_development_dependency 'vcr', '~> 1.10'
+  gem.add_development_dependency 'webmock', '~> 1.7'
+  gem.authors = ["Wynn Netherland", "Josh Kalderimis"]
+  gem.description = %q{Ruby wrapper for the LinkedIn API}
+  gem.email = ['wynn.netherland@gmail.com', 'josh.kalderimis@gmail.com']
+  gem.files = `git ls-files`.split("\n")
+  gem.homepage = 'http://github.com/pengwynn/linkedin'
+  gem.name = 'linkedin-drspin'
+  gem.require_paths = ['lib']
+  gem.summary = gem.description
+  gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.version = LinkedIn::VERSION::STRING
+end

data/spec/cases/api_spec.rb

@@ -0,0 +1,92 @@
+require 'helper'
+
+describe LinkedIn::Api do
+  before do
+    LinkedIn.default_profile_fields = nil
+    client.stub(:consumer).and_return(consumer)
+    client.authorize_from_access('atoken', 'asecret')
+  end
+
+  let(:client){LinkedIn::Client.new('token', 'secret')}
+  let(:consumer){OAuth::Consumer.new('token', 'secret', {:site => 'https://api.linkedin.com'})}
+
+  it "should be able to view the account profile" do
+    stub_request(:get, "https://api.linkedin.com/v1/people/~").to_return(:body => "{}")
+    client.profile.should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to view public profiles" do
+    stub_request(:get, "https://api.linkedin.com/v1/people/id=123").to_return(:body => "{}")
+    client.profile(:id => 123).should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to view connections" do
+    stub_request(:get, "https://api.linkedin.com/v1/people/~/connections").to_return(:body => "{}")
+    client.connections.should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to view network_updates" do
+    stub_request(:get, "https://api.linkedin.com/v1/people/~/network/updates").to_return(:body => "{}")
+    client.network_updates.should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to search with a keyword if given a String" do
+    stub_request(:get, "https://api.linkedin.com/v1/people-search?keywords=business").to_return(:body => "{}")
+    client.search("business").should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to search with an option" do
+    stub_request(:get, "https://api.linkedin.com/v1/people-search?first-name=Javan").to_return(:body => "{}")
+    client.search(:first_name => "Javan").should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to search with an option and fetch specific fields" do
+    stub_request(:get, "https://api.linkedin.com/v1/people-search:(num-results,total)?first-name=Javan").to_return(:body => "{}")
+    client.search(:first_name => "Javan", :fields => ["num_results", "total"]).should be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to share a new status" do
+    stub_request(:post, "https://api.linkedin.com/v1/people/~/shares").to_return(:body => "", :status => 201)
+    response = client.add_share(:comment => "Testing, 1, 2, 3")
+    response.body.should == ""
+    response.code.should == "201"
+  end
+
+  context "Company API" do
+    use_vcr_cassette
+
+    it "should be able to view a company profile" do
+      stub_request(:get, "https://api.linkedin.com/v1/companies/id=1586").to_return(:body => "{}")
+      client.company(:id => 1586).should be_an_instance_of(LinkedIn::Mash)
+    end
+
+    it "should be able to view a company by universal name" do
+      stub_request(:get, "https://api.linkedin.com/v1/companies/universal-name=acme").to_return(:body => "{}")
+      client.company(:name => 'acme').should be_an_instance_of(LinkedIn::Mash)
+    end
+
+    it "should be able to view a company by e-mail domain" do
+      stub_request(:get, "https://api.linkedin.com/v1/companies/email-domain=acme.com").to_return(:body => "{}")
+      client.company(:domain => 'acme.com').should be_an_instance_of(LinkedIn::Mash)
+    end
+
+    it "should load correct company data" do
+      client.company(:id => 1586).name.should == "Amazon"
+
+      data = client.company(:id => 1586, :fields => %w{ id name industry locations:(address:(city state country-code) is-headquarters) employee-count-range })
+      data.id.should == 1586
+      data.name.should == "Amazon"
+      data.employee_count_range.name.should == "10001+"
+      data.industry.should == "Internet"
+      data.locations.all[0].address.city.should == "Seattle"
+      data.locations.all[0].is_headquarters.should == true
+    end
+  end
+
+  context "Errors" do
+    it "should raise AccessDeniedError when LinkedIn returns 403 status code" do
+      stub_request(:get, "https://api.linkedin.com/v1/people-search?first-name=Javan").to_return(:body => "{}", :status => 403)
+      expect{ client.search(:first_name => "Javan") }.to raise_error(LinkedIn::Errors::AccessDeniedError)
+    end
+  end
+end

data/spec/cases/linkedin_spec.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+describe LinkedIn do
+
+  before(:each) do
+    LinkedIn.token = nil
+    LinkedIn.secret = nil
+    LinkedIn.default_profile_fields = nil
+  end
+
+  it "should be able to set the consumer token and consumer secret" do
+    LinkedIn.token  = 'consumer_token'
+    LinkedIn.secret = 'consumer_secret'
+
+    LinkedIn.token.should  == 'consumer_token'
+    LinkedIn.secret.should == 'consumer_secret'
+  end
+
+  it "should be able to set the default profile fields" do
+    LinkedIn.default_profile_fields = ['education', 'positions']
+
+    LinkedIn.default_profile_fields.should == ['education', 'positions']
+  end
+
+  it "should be able to set the consumer token and consumer secret via a configure block" do
+    LinkedIn.configure do |config|
+      config.token  = 'consumer_token'
+      config.secret = 'consumer_secret'
+      config.default_profile_fields = ['education', 'positions']
+    end
+
+    LinkedIn.token.should  == 'consumer_token'
+    LinkedIn.secret.should == 'consumer_secret'
+    LinkedIn.default_profile_fields.should == ['education', 'positions']
+  end
+
+end