omnicontacts 0.1.0

data/lib/omnicontacts/importer.rb

@@ -0,0 +1,9 @@
+module OmniContacts
+  module Importer
+
+    autoload :Gmail, "omnicontacts/importer/gmail"
+    autoload :Yahoo, "omnicontacts/importer/yahoo"
+    autoload :Hotmail, "omnicontacts/importer/hotmail"
+
+  end
+end

data/lib/omnicontacts/importer/gmail.rb

@@ -0,0 +1,54 @@
+require "omnicontacts/middleware/oauth2"
+require "rexml/document"
+
+module OmniContacts
+  module Importer
+    class Gmail < Middleware::OAuth2
+
+      attr_reader :auth_host, :authorize_path, :auth_token_path, :scope
+
+      def initialize *args
+        super *args
+        @auth_host = "accounts.google.com"
+        @authorize_path = "/o/oauth2/auth"
+        @auth_token_path = "/o/oauth2/token"
+        @scope = "https://www.google.com/m8/feeds"
+        @contacts_host = "www.google.com"
+        @contacts_path = "/m8/feeds/contacts/default/full"
+      end
+
+      def fetch_contacts_using_access_token access_token, token_type
+        contacts_response = https_get(@contacts_host, @contacts_path, contacts_req_params, contacts_req_headers(access_token, token_type))    
+        parse_contacts contacts_response
+      end
+
+      private 
+
+      def contacts_req_params
+        { "max-results" => "100"}
+      end
+
+      def contacts_req_headers token, token_type
+        {"GData-Version" => "3.0",  "Authorization" => "#{token_type} #{token}"}  
+      end
+
+      def parse_contacts contacts_as_xml
+        xml = REXML::Document.new(contacts_as_xml)
+        contacts = []
+        xml.elements.each('//entry') do |entry|
+          gd_email = entry.elements['gd:email']
+          if gd_email
+            contact = {:email => gd_email.attributes['address']}
+            gd_name = entry.elements['gd:name']
+            if gd_name
+              contact[:name] = gd_name.elements['gd:fullName'].text
+            end
+            contacts << contact
+          end
+        end
+        contacts 
+      end
+
+    end
+  end
+end

data/lib/omnicontacts/importer/hotmail.rb

@@ -0,0 +1,46 @@
+require "omnicontacts/middleware/oauth2"
+require "json"
+
+module OmniContacts
+  module Importer
+    class Hotmail < Middleware::OAuth2
+
+      attr_reader :auth_host, :authorize_path, :auth_token_path, :scope
+
+      def initialize *args
+        super *args
+        @auth_host = "oauth.live.com"
+        @authorize_path = "/authorize"
+        @scope = "wl.basic"
+        @auth_token_path = "/token"
+        @contacts_host = "apis.live.net"
+        @contacts_path = "/v5.0/me/contacts"
+      end
+
+      def fetch_contacts_using_access_token access_token, access_token_secret
+        contacts_response = https_get(@contacts_host, @contacts_path, :access_token =>access_token)
+        contacts_from_response contacts_response
+      end
+
+      private
+
+      def contacts_from_response contacts_as_json
+        json = JSON.parse(escape_windows_format(contacts_as_json)) 
+        result = []
+        json["data"].each do |contact|
+          result << {:email => contact["name"]} if valid_email? contact["name"]
+        end
+        result
+      end
+
+      def escape_windows_format value
+        value.gsub(/[\r\s]/,'')
+      end
+
+      def valid_email? value
+        /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/.match(value)
+      end
+
+    end
+  end
+end

data/lib/omnicontacts/importer/yahoo.rb

@@ -0,0 +1,64 @@
+require "omnicontacts/middleware/oauth1"
+require "json"
+
+module OmniContacts
+  module Importer
+    class Yahoo < Middleware::OAuth1 
+
+      attr_reader :auth_host, :auth_token_path, :auth_path, :access_token_path
+
+      def initialize *args
+        super *args
+        @auth_host = "api.login.yahoo.com"
+        @auth_token_path = "/oauth/v2/get_request_token"
+        @auth_path = "/oauth/v2/request_auth"
+        @access_token_path = "/oauth/v2/get_token"
+        @contacts_host = "social.yahooapis.com"
+      end
+
+      def fetch_contacts_from_token_and_verifier auth_token, auth_token_secret, auth_verifier
+        (access_token, access_token_secret, guid) = fetch_access_token(auth_token, auth_token_secret, auth_verifier, ["xoauth_yahoo_guid"])
+        contacts_path = "/v1/user/#{guid}/contacts"
+        contacts_response = http_get(@contacts_host, contacts_path, contacts_req_params(access_token, access_token_secret, contacts_path) )
+        contacts_from_response contacts_response
+      end
+
+      private
+
+      def contacts_req_params access_token, access_token_secret, contacts_path
+        params = {
+          :format => "json",
+          :oauth_consumer_key => consumer_key,
+          :oauth_nonce => encode(random_string),
+          :oauth_signature_method => "HMAC-SHA1",
+          :oauth_timestamp => timestamp,
+          :oauth_token => access_token,
+          :oauth_version => OmniContacts::Authorization::OAuth1::OAUTH_VERSION,
+          :view => "compact"
+        } 
+        contacts_url = "http://#{@contacts_host}#{contacts_path}"
+        params["oauth_signature"] = oauth_signature("GET", contacts_url, params, access_token_secret)
+        params
+      end
+
+      def contacts_from_response contacts_as_json 
+        json = JSON.parse(contacts_as_json)
+        result = []
+        json["contacts"]["contact"].each do |entry|
+          contact = {}
+          entry["fields"].each do |field|
+            contact[:email] = field["value"] if field["type"] == "email"
+            if field["type"] == "name"
+              name = field["value"]["givenName"]
+              surname = field["value"]["familyName"]
+              contact[:name] = "#{name} #{surname}" if name && surname
+            end
+          end
+          result << contact if contact[:email]
+        end
+        result
+      end
+
+    end
+  end
+end

data/lib/omnicontacts/middleware/base_oauth.rb

@@ -0,0 +1,97 @@
+# This class contains the common behavior for middlewares
+# implementing either versions of OAuth.
+#
+# Extending classes are required to implement
+# the following methods:
+# * request_authorization_from_user 
+# * fetch_contatcs
+module OmniContacts
+  module Middleware
+    class BaseOAuth
+
+      attr_reader :ssl_ca_file
+
+      def initialize app, options
+        @app = app
+        @listening_path = "/contacts/" + class_name
+        @ssl_ca_file = options[:ssl_ca_file]
+      end
+
+      private
+
+      def class_name
+        self.class.name.split('::').last.downcase
+      end
+
+      public
+
+      # Rack callback. It handles three cases:
+      # * user visit middleware entru point. 
+      #   In this case request_authorization_from_user is called
+      # * user is redirected back to the application 
+      #   from the authorization site. In this case the list
+      #   of contacts is fetched and stored in the variables
+      #   omnicontacts.contacts within the Rack env variable.
+      #   Once that is done the next middleware component is called.
+      # * user visits any other resource. In this case the request
+      #   is simply forwarded to the next middleware component.
+      def call env
+        @env = env
+        if env["PATH_INFO"] =~ /^#{@listening_path}\/?$/
+          handle_initial_request
+        elsif env["PATH_INFO"] =~ /^#{redirect_path}/
+          handle_callback
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def handle_initial_request
+        execute_and_rescue_exceptions do 
+          request_authorization_from_user
+        end
+      end
+
+      def handle_callback
+        execute_and_rescue_exceptions do 
+          @env["omnicontacts.contacts"] = fetch_contacts
+          @app.call(@env)
+        end
+      end
+
+      #  This method rescues executes a block of code and
+      #  rescue all exceptions. In case of an exception the 
+      #  user is redirected to the failure endpoint.
+      def execute_and_rescue_exceptions 
+        yield
+      rescue AuthorizationError => e
+        handle_error :not_authorized, e
+      rescue ::Timeout::Error, ::Errno::ETIMEDOUT => e
+        handle_error :timeout, e
+      rescue  ::RuntimeError => e
+        handle_error :internal_error, e
+      end
+
+      def handle_error error_type, exception
+        logger << ("Error #{error_type} while processing #{@env["PATH_INFO"]}: #{exception.message}") if logger
+        [302, {"location" => "/contacts/failure?error_message=#{error_type}"}, []]
+      end
+
+      def session
+        raise "You must provide a session to use OmniContacts" unless @env["rack.session"]
+        @env["rack.session"]
+      end
+
+      def logger
+        @env["rack.errors"] if @env
+      end
+
+      def base_prop_name
+        "omnicontacts." + class_name
+      end
+
+    end
+  end
+end

data/lib/omnicontacts/middleware/oauth1.rb

@@ -0,0 +1,68 @@
+require "omnicontacts/authorization/oauth1"
+require "omnicontacts/middleware/base_oauth"
+
+# This class is an OAuth 1.0 Rack middleware.
+#
+# Extending classes are required to 
+# implement the following methods:
+# * fetch_token_from_token_and_verifier -> this method has to
+#   fetch the list of contacts from the authorization server.
+module OmniContacts
+  module Middleware
+    class OAuth1 < BaseOAuth
+      include Authorization::OAuth1
+
+      attr_reader :consumer_key, :consumer_secret, :callback_path
+
+      def initialize app, consumer_key, consumer_secret, options = {}
+        super app, options
+        @consumer_key = consumer_key
+        @consumer_secret = consumer_secret
+        @callback_path = options[:callback_path] ||= "/contacts/#{class_name}/callback"
+        @token_prop_name = "#{base_prop_name}.oauth_token"
+      end
+
+      def callback
+        host_url_from_rack_env(@env) + callback_path
+      end
+
+      alias :redirect_path :callback_path
+
+      # Obtains an authorization token from the server,
+      # stores it and the session and redirect the user
+      # to the authorization website.
+      def request_authorization_from_user
+        (auth_token, auth_token_secret) = fetch_authorization_token
+        session[@token_prop_name] = auth_token
+        session[token_secret_prop_name(auth_token)] = auth_token_secret
+        redirect_to_authorization_site(auth_token) 
+      end
+
+      def token_secret_prop_name oauth_token
+        "#{base_prop_name}.#{oauth_token}.oauth_token_secret"  
+      end
+
+      def redirect_to_authorization_site auth_token
+        [302, {"location" => authorization_url(auth_token)}, []]
+      end
+
+      # Parses the authorization token from the query string and 
+      # obtain the relative secret from the session.
+      # Finally it calls fetch_contacts_from_token_and_verifier.
+      # If token is found in the query string an AuhorizationError
+      # is raised.
+      def fetch_contacts
+        params = query_string_to_map(@env["QUERY_STRING"])
+        oauth_token = params["oauth_token"]
+        oauth_verifier = params["oauth_verifier"]
+        oauth_token_secret = session[token_secret_prop_name(oauth_token)]
+        if oauth_token && oauth_verifier && oauth_token_secret
+          fetch_contacts_from_token_and_verifier(oauth_token, oauth_token_secret, oauth_verifier)
+        else
+          raise AuthorizationError.new("User did not grant access to contacts list")
+        end
+      end
+
+    end
+  end
+end

data/lib/omnicontacts/middleware/oauth2.rb

@@ -0,0 +1,66 @@
+require "omnicontacts/authorization/oauth2"
+require "omnicontacts/middleware/base_oauth"
+
+# This class is a OAuth 2 Rack middleware.
+#
+# Extending class are required to implement
+# the following methods:
+# * fetch_contacts_using_access_token -> it 
+#   fetches the list of contacts from the authorization
+#   server.
+module OmniContacts
+  module Middleware
+    class OAuth2 < BaseOAuth
+      include Authorization::OAuth2
+
+      attr_reader :client_id, :client_secret, :redirect_path
+
+      def initialize app, client_id, client_secret, options ={}
+        super app, options
+        @client_id = client_id
+        @client_secret = client_secret
+        @redirect_path = options[:redirect_path] ||= "/contacts/#{class_name}/callback"
+        @ssl_ca_file = options[:ssl_ca_file]
+      end
+
+      def request_authorization_from_user
+        [302, {"location" => authorization_url}, []]
+      end
+
+      def redirect_uri
+        host_url_from_rack_env(@env) + redirect_path
+      end
+
+      # It extract the authorization code from the query string.
+      # It uses it to obtain an access token.
+      # If the authorization code has a refresh token associated 
+      # with it in the session, it uses the obtain an access token.
+      # It fetches the list of contacts and stores the refresh token
+      # associated with the access token in the session.
+      # Finally it returns the list of contacts.
+      # If no authorization code is found in the query string an
+      # AuthoriazationError is raised.
+      def fetch_contacts
+        code =  query_string_to_map(@env["QUERY_STRING"])["code"]
+        if code
+          refresh_token = session[refresh_token_prop_name(code)]
+          (access_token, token_type, refresh_token) = if refresh_token
+                                                        refresh_access_token(refresh_token)
+                                                      else
+                                                        fetch_access_token(code)
+                                                      end
+          contacts = fetch_contacts_using_access_token(access_token, token_type)
+          session[refresh_token_prop_name(code)] = refresh_token if refresh_token
+          contacts
+        else
+          raise AuthorizationError.new("User did not grant access to contacts list")
+        end
+      end
+
+      def refresh_token_prop_name code
+        "#{base_prop_name}.#{code}.refresh_token"
+      end
+
+    end
+  end
+end

data/omnicontacts.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path('../lib/omnicontacts', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name = 'omnicontacts'
+  gem.description = %q{A generalized Rack middleware for importing contacts from major email providers.}
+  gem.authors = ['Diego Castorina']
+  gem.email = ['diegocastorina@gmail.com']
+
+  gem.add_runtime_dependency 'rack'
+  gem.add_runtime_dependency 'json'
+
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rack-test'
+  gem.add_development_dependency 'rspec'
+
+  gem.version = OmniContacts::VERSION
+  gem.files = `git ls-files`.split("\n")
+  gem.homepage = 'http://github.com/Diego81/omnicontacts'
+  gem.require_paths = ['lib']
+  gem.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if gem.respond_to? :required_rubygems_version=
+  gem.summary = gem.description
+  gem.test_files = `git ls-files -- {spec}/*`.split("\n")
+end

data/spec/omnicontacts/authorization/oauth1_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+require "omnicontacts/authorization/oauth1"
+
+describe OmniContacts::Authorization::OAuth1 do 
+
+  before(:all) do 
+    OAuth1TestClass= Struct.new(:consumer_key, :consumer_secret, :auth_host, :auth_token_path, :auth_path, :access_token_path, :callback)
+    class OAuth1TestClass 
+      include OmniContacts::Authorization::OAuth1
+    end
+  end
+
+  let(:test_target) do
+    OAuth1TestClass.new("consumer_key", "secret1", "auth_host", "auth_token_path", "auth_path", "access_token_path", "callback")
+  end
+
+  describe "fetch_authorization_token" do 
+
+    it "should request the token providing all mandatory parameters" do 
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:oauth_consumer_key].should eq(test_target.consumer_key)
+        params[:oauth_nonce].should_not be_nil
+        params[:oauth_signature_method].should eq("PLAINTEXT")
+        params[:oauth_signature].should eq(test_target.consumer_secret + "%26")
+        params[:oauth_timestamp].should_not be_nil
+        params[:oauth_version].should eq("1.0")
+        params[:oauth_callback].should eq(test_target.callback)
+        "oauth_token=token&oauth_token_secret=token_secret"
+      end
+      test_target.fetch_authorization_token
+    end
+
+    it "should successfully parse the result" do 
+      test_target.should_receive(:https_post).and_return("oauth_token=token&oauth_token_secret=token_secret")
+      test_target.fetch_authorization_token.should eq(["token", "token_secret"])
+    end
+
+    it "should raise an error if request is invalid" do 
+      test_target.should_receive(:https_post).and_return("invalid_request")
+      expect{test_target.fetch_authorization_token}.should raise_error
+    end
+
+  end
+
+  describe "authorization_url" do 
+    subject{test_target.authorization_url("token")}
+    it{should eq("https://#{test_target.auth_host}#{test_target.auth_path}?oauth_token=token")}
+  end
+
+  describe "fetch_access_token" do 
+    it "should request the access token using all required parameters" do 
+      auth_token = "token"
+      auth_token_secret = "token_secret"
+      auth_verifier = "verifier"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.access_token_path)
+        params[:oauth_consumer_key].should eq(test_target.consumer_key)
+        params[:oauth_nonce].should_not be_nil
+        params[:oauth_signature_method].should eq("PLAINTEXT")
+        params[:oauth_version].should eq("1.0")
+        params[:oauth_signature].should eq("#{test_target.consumer_secret}%26#{auth_token_secret}")
+        params[:oauth_token].should eq(auth_token)
+        params[:oauth_verifier].should eq(auth_verifier)
+        "oauth_token=access_token&oauth_token_secret=access_token_secret&other_param=other_value"
+      end
+      test_target.fetch_access_token auth_token, auth_token_secret, auth_verifier, ["other_param"]
+    end
+
+    it "should successfully extract access_token and the other fields" do 
+      test_target.should_receive(:https_post).and_return("oauth_token=access_token&oauth_token_secret=access_token_secret&other_param=other_value")
+      test_target.fetch_access_token("token","token_scret","verified",["other_param"]).should eq(["access_token", "access_token_secret", "other_value"])
+    end
+  end
+
+  describe "oauth_signature" do
+    subject{ test_target.oauth_signature("GET", "http://social.yahooapis.com/v1/user", {:name => "diego", :surname => "castorina"}, "secret2")}
+    it{ should eq("ZqWoQISWcuz%2FSDnDxWihtsFDKwc%3D")}
+  end
+end