linkedin2 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac298d199dd70fa33629431f471bd38f7247ce8c
-  data.tar.gz: 0487998919736006a7dcc828a1d847a29cf138f4
+  metadata.gz: 97c526507b2313e93d3e8f8774e21ddac5b9a64b
+  data.tar.gz: 59b303455324238c1d9328d7e20cb165ea982218
 SHA512:
-  metadata.gz: 7db8a53f200a4d425ac735d6f92fc2521b3caaf6d6fb878069abd874d7114b719797e1b63bbc5f15240fdce1a1035ae1179d3c30199af46e02dcb8acfe3b9fa5
-  data.tar.gz: 9472503155331275a6ae09f763a887b9985f65c48950c38f02b5beb0375625a9c37f66e5a4c2a89854694941b02c7841c5de4e95f4569d09d407c39c6c50a43f
+  metadata.gz: b48333d3d41d0ecb1ac40cb11853ea92378822cb30e7c1906eba0841851d6f7b11ee630853d472ec91193284b2d703fb6741696f8c4bb5fcb31e3c8667f2a69e
+  data.tar.gz: 8d3f033c03d7232f64825b7a0b3bb8577e33e4d2455506298c9ae07de9b9389a2ad6dca4f10f5bf43c2236f1f7c906635ad2684f87fe78d6a3a4ca36f535e319

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-pro
+repo_token: eqey1MAhYCCz33208mWozM0Z3DwMxvGCR

data/.gitignore

@@ -16,3 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 linkedin.yml
+.DS_Store
+.ruby-version

data/.rspec

@@ -1,3 +1,3 @@
+--format documentation
 --color
---format=nested
---backtrace
+--require spec_helper

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
-  - "1.9.3"
   - "2.0.0"
+  - "2.1.2"

data/README.md

@@ -1,7 +1,7 @@
 # LinkedIn 2
-[![Build Status](https://travis-ci.org/bobbrez/linkedin2.png?branch=master)](https://travis-ci.org/bobbrez/linkedin2)
-[![Code Climate](https://codeclimate.com/github/bobbrez/linkedin2.png)](https://codeclimate.com/github/bobbrez/linkedin2)
-
+[![Build Status](https://travis-ci.org/bobbrez/linkedin2.svg?branch=master)](https://travis-ci.org/bobbrez/linkedin2)
+[![Coverage Status](https://img.shields.io/coveralls/bobbrez/linkedin2.svg)](https://coveralls.io/r/bobbrez/linkedin2)
+[![Code Climate](https://codeclimate.com/github/bobbrez/linkedin2/badges/gpa.svg)](https://codeclimate.com/github/bobbrez/linkedin2)
 A modernized LinkedIn Ruby client.
 
 ## Installation

data/Rakefile

@@ -3,7 +3,7 @@ require 'rspec/core/rake_task'
 
 desc 'Open an irb session preloaded with this library'
 task :console do
-  sh 'irb -rubygems -I lib -r linkedin2.rb'
+  sh 'irb -rubygems -rpry -I lib -r linkedin2.rb'
 end
 
 RSpec::Core::RakeTask.new

data/lib/linkedin/api.rb

@@ -0,0 +1,16 @@
+module LinkedIn
+  module API
+    Dir[ File.expand_path('../api/**/*.rb', __FILE__) ].each { |f| require f }
+
+    def self.included(base)
+      base.send :include, LinkedIn::API::Authentication,
+                          LinkedIn::API::Companies,
+                          LinkedIn::API::Groups,
+                          LinkedIn::API::Invitation,
+                          LinkedIn::API::Jobs,
+                          LinkedIn::API::Messaging,
+                          LinkedIn::API::NetworkUpdates,
+                          LinkedIn::API::People
+    end
+  end
+end

data/lib/linkedin/api/authentication.rb

@@ -1,21 +1,19 @@
 module LinkedIn
   module API
     module Authentication
-      attr_reader :state
-
-      def authorize_url(params = {})
-        params.reverse_merge! config.to_h.slice :scope, :state, :redirect_uri
+      def authorize_url(**params)
+        params.reverse_merge! configuration.to_h.slice :scope, :state, :redirect_uri
         params[:scope] = serialize_scope params[:scope]
-        auth_code.authorize_url params
+        credentials.auth_code.authorize_url params
       end
 
       def request_access_token(authorization_code, params = {})
         raise Error::CSRF.new state, params[:state] if params[:state] && params[:state] != state
 
-        params.reverse_merge! redirect_uri: config.redirect_uri
+        params.reverse_merge! redirect_uri: configuration.redirect_uri
         opts = { mode: :query, param_name: 'oauth2_access_token' }
 
-        self.access_token = auth_code.get_token authorization_code, params, opts
+        credentials.auth_code.get_token authorization_code, params, opts
       end
 
       private

data/lib/linkedin/api/companies.rb

@@ -1,19 +1,25 @@
 module LinkedIn
   module API
     module Companies
-      def company(options={})
-        selector = if options[:selector].respond_to? :each
-          "::(#{options[:selector].join(',')})" 
-        else
-          "/#{options[:selector]}"
-        end
+      def company(*selector, filter: nil, **opts)
+        root = 'companies'
+
+        selector.compact!
+        selector = selector.first if selector.size == 1
 
-        fields = options[:fields]
-        fields_string = fields.blank? ? '' : ":(#{Permissions.render_permissions fields})"
+        unless filter.blank?
+          filter = Hash[ *filter.to_s.split('=') ] unless filter.respond_to? :keys
+          opts[:params] = {} if opts[:params].blank?
+          opts[:params].to_h.merge! filter
+          selector = nil
+        end
 
-        filter = "?#{options[:filter]}" if options[:filter].present?
+        if selector.respond_to? :each
+          selector = "companies::(#{ selector.map(&:to_param).join(',') })"
+          root = nil
+        end
 
-        get "v1/companies#{selector}#{fields_string}#{filter}"
+        execute root, opts.merge(selector: selector)
       end
     end
   end

data/lib/linkedin/api/invitation.rb

@@ -0,0 +1,39 @@
+module LinkedIn
+  module API
+    module Invitation
+      def connect_with(recipient_selector, subject, message, type: :friend, x_auth_token: nil)
+        if x_auth_token.blank?
+          target_profile = profile recipient_selector, Fields::PROFILE_API_STD_PROFILE_REQ
+          x_auth_token = target_profile.body.apiStandardProfileRequest_.headers_.values_.first.value
+        end
+
+        x_auth_name, x_auth_value = *x_auth_token.split(':')
+
+        connection_body = build_connection_body selector: recipient_selector, subject: subject,
+                                                message: message, type: type,
+                                                auth_name: x_auth_name, auth_value: x_auth_value
+
+        execute 'people/~/mailbox', method: :post, body: connection_body
+      end
+
+      private
+
+      def build_connection_body(**args)
+        [:selector, :subject, :message, :type, :auth_name, :auth_value].each do |key|
+          raise ArgumentError.new "Missing / blank argument `#{key}`" if args[key].blank?
+        end
+
+        { recipients: { values: [ { person: { _path: "/people/#{args[:selector].to_param}" } } ] },
+          subject: args[:subject],
+          body: args[:message],
+          'item-content' => {
+            'invitation-request' => {
+              'connect-type' => args[:type],
+              authorization: { name: args[:auth_name], value: args[:auth_value] }
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/linkedin/api/messaging.rb

@@ -0,0 +1,24 @@
+module LinkedIn
+  module API
+    module Messaging
+      def message(subject, message, recipient_selectors, **opts)
+        message_body = build_message_body selectors: [recipient_selectors].flatten,
+                                          subject: subject, message: message
+
+        execute 'people/~/mailbox', opts.merge(method: :post, body: message_body)
+      end
+
+      private
+
+      def build_message_body(**args)
+        [:selectors, :subject, :message].each do |key|
+          raise ArgumentError.new "Missing / blank argument `#{key}`" if args[key].blank?
+        end
+
+        recipients = args[:selectors].map { |sel| { person: { _path: "/people/#{sel.to_param}" } } }
+
+        { recipients: { values: recipients }, subject: args[:subject], body: args[:message] }
+      end
+    end
+  end
+end

data/lib/linkedin/api/network_updates.rb

@@ -1,16 +1,12 @@
 module LinkedIn
   module API
     module NetworkUpdates
-      def network_updates(options = {})
-        get ['v1/people/~/network/updates', options[:selector], options[:attached_object_type]].compact.join '/'
-      end
-
-      def network_update_comments(options = {})
-        network_updates(options.merge attached_object_type: 'update-comments')
-      end
+      def network_updates(selector = '~', key: nil, type: nil, **opts)
+        path = ['network','updates']
+        path << { key: key }.to_param if key
+        path << type
 
-      def network_update_likes(options = {})
-        network_updates(options.merge attached_object_type: 'likes')
+        execute 'people', opts.merge(selector: selector, path: path.compact.join('/'))
       end
     end
   end

data/lib/linkedin/api/people.rb

@@ -0,0 +1,18 @@
+module LinkedIn
+  module API
+    module People
+      def profile(selector = '~', **opts)
+        execute 'people', opts.merge(selector: selector)
+      end
+
+      def connections(selector = '~', **opts)
+        execute 'people', opts.merge(selector: selector, path: 'connections')
+      end
+
+      def people_search(query, **opts)
+        wrapped_fields = opts[:fields].blank? ? nil : { people: opts[:fields] }
+        execute 'people-search', opts.merge(params: query, fields: wrapped_fields)
+      end
+    end
+  end
+end

data/lib/linkedin/client.rb

@@ -1,96 +1,58 @@
 module LinkedIn
   class Client
-    extend Forwardable
-
     include Configuration
-    include LinkedIn::API::Authentication
-    include LinkedIn::API::Profiles
-    include LinkedIn::API::NetworkUpdates
-    include LinkedIn::API::Companies
-
-    HTTP_METHODS = [:get, :post, :put, :patch, :delete, :headers].freeze
-
-    attr_writer :profile_fields
-    attr_reader :access_token
+    include LinkedIn::API
 
-    def_delegators :@access_token, :expires?, :expired?, :request
-
-    def initialize(options={}, &block)
-      configure options, &block
-      self.access_token ||= self.config.access_token.to_s
+    def initialize(**config, &block)
+      configure config, &block
     end
 
-    def auth_code
-      connection.auth_code
+    def credentials
+      @credentials ||= Credentials.new configuration
     end
 
     def connection
-      @connection ||= OAuth2::Client.new config.key, config.secret, oauth2_options do |faraday|
-        faraday.request :url_encoded
-        faraday.request :json
-        faraday.request :linkedin_format, config.request_format
-
-        faraday.response :mashify
-        faraday.response :linkedin_errors
-        faraday.response :logger, config.logger
-        faraday.response :json, content_type: /\bjson$/
-
-        faraday.adapter :net_http
+      @connection ||= Faraday.new 'https://api.linkedin.com' do |conn|
+        conn.request :json
+        conn.request :url_encoded
+        conn.request :linkedin_credentials, configuration
+        conn.request :linkedin_format
+        conn.request :linkedin_user_agent
+
+        conn.response :linkedin_errors
+        conn.response :mashify
+        conn.response :logger, configuration.logger
+        conn.response :json, content_type: /\bjson$/
+
+        conn.adapter Faraday.default_adapter
       end
     end
 
-    def access_token=(token)
-      if token.kind_of? String
-        options = { access_token: token, mode: :query, param_name: 'oauth2_access_token' }
-        return @access_token = OAuth2::AccessToken.from_hash(connection, options)
-      end
-
-      @access_token = token
+    def headers
+      @headers ||= {}
     end
 
-    def profile_fields
-      return @profile_fields if @profile_fields
-      scopes = config.scope unless config.scope.respond_to?(:values)
-      scopes ||= config.scope
-
-      @profile_fields = scopes.reduce([]) { |fields, scope| fields + LinkedIn.send(scope) }
-    end
-
-    def method_missing(method, *args, &body)
-      return simple_request(method, args[0], (args[1] || {}), &body) if HTTP_METHODS.include? method
-      super
-    end
-
-    def self.default_config
-      {
-        request_format: :json,
-
-        key: nil,
-        secret: nil,
-        access_token: nil,
-
-        scope: ['r_basicprofile'],
-        state: Utils.generate_random_state,
-        redirect_uri: 'http://localhost',
-
-        logger: Logger.new('/dev/null')
-      }
+    def params
+      @params ||= {}
     end
 
     private
 
-    def simple_request(method, path, options={}, &body)
-      request(method, path, options, &body).body
+    def override(global, overrides)
+      global.to_h.merge overrides.to_h
     end
 
-    def auth_code
-      connection.auth_code unless connection.nil?
-    end
+    def execute(root, method: :get, selector: nil, fields: nil, **opts)
+      rendered_fields = Fields.render fields
+      query = ['v1', root, selector.to_param, opts[:path]].compact.join('/').concat(rendered_fields)
+
+      response = connection.send method, query do |req|
+        req.headers.update override(@headers, opts[:headers])
+        req.params.update override(@params, opts[:params])
+        req.body = opts[:body].to_json if opts[:body]
+      end
 
-    def oauth2_options
-      { site:          'https://api.linkedin.com',
-        authorize_url: 'https://www.linkedin.com/uas/oauth2/authorization',
-        token_url:     'https://www.linkedin.com/uas/oauth2/accessToken' }
+      Response.new response
     end
   end
 end

data/lib/linkedin/configuration.rb

@@ -1,41 +1,56 @@
 module LinkedIn
   module Configuration
     module ClassConfiguration
-      def config
-        @config ||= reset
+      def default_config
+        {
+          request_format: :json,
+
+          app_key: nil,
+          app_secret: nil,
+          access_token: nil,
+
+          scope: ['r_basicprofile'],
+          redirect_uri: 'http://localhost',
+
+          logger: Logger.new('/dev/null')
+        }
+      end
+
+      def configuration
+        @configuration ||= OpenStruct.new default_config
       end
 
       def reset
-        @config = OpenStruct.new default_config
+        configuration.marshal_load default_config
       end
     end
 
     module InstanceConfiguration
-      def config
-        @config ||= reset
+      def configuration
+        @configuration ||= self.class.configuration.dup
       end
 
       def reset
-        @config = self.class.config.dup
+        @configuration.marshal_load self.class.configuration
       end
     end
 
     module BaseConfiguration
       def configure(config={}, &block)
-        self.config.marshal_load self.config.marshal_dump.merge(config)
+        self.configuration.marshal_load self.configuration.marshal_dump.merge(config)
 
-        yield self.config if block_given?
+        yield self.configuration if block_given?
 
-        self.config
+        self.configuration
       end
 
-      def load(file_path='linkedin.yml')
+      def load(file_path = 'linkedin.yml')
         config = YAML::load(File.open(file_path)).symbolize_keys
         configure config
       end
 
       def config(*keys)
-        config.marshal_dump.slice(*keys)
+        configuration.marshal_dump.slice(*keys)
       end
     end