muck-contacts 2.6.1

data/lib/contacts/base.rb

@@ -0,0 +1,226 @@
+require "cgi"
+require "net/http"
+require "net/https"
+require "uri"
+require "zlib"
+require "stringio"
+require "thread"
+require "erb"
+
+class Contacts
+  TYPES = {}
+  FILETYPES = {}
+  VERSION = "1.4.1"
+
+  class Base
+    def initialize(login, password, options={})
+      @login = login
+      @password = password
+      @connections = {}
+      @options = options
+      connect
+    end
+
+    def connect
+      raise AuthenticationError, "Login and password must not be nil, login: #{@login.inspect}, password: #{@password.inspect}" if @login.nil? || @login.empty? || @password.nil? || @password.empty?
+      real_connect
+    end
+
+    def connected?
+      @cookies && !@cookies.empty?
+    end
+
+    def contacts(options = {})
+      return @contacts if @contacts
+      if connected?
+        url = URI.parse(contact_list_url)
+        http = open_http(url)
+        resp, data = http.get("#{url.path}?#{url.query}",
+          "Cookie" => @cookies
+        )
+
+        if resp.code_type != Net::HTTPOK
+          raise ConnectionError, self.class.const_get(:PROTOCOL_ERROR)
+        end
+
+        parse(data, options)
+      end
+    end
+
+    def login
+      @attempt ||= 0
+      @attempt += 1
+
+      if @attempt == 1
+        @login
+      else
+        if @login.include?("@#{domain}")
+          @login.sub("@#{domain}","")
+        else
+          "#{@login}@#{domain}"
+        end
+      end
+    end
+
+    def password
+      @password
+    end
+
+    def skip_gzip?
+      false
+    end
+  private
+
+    def domain
+      @d ||= URI.parse(self.class.const_get(:URL)).host.sub(/^www\./,'')
+    end
+
+    def contact_list_url
+      self.class.const_get(:CONTACT_LIST_URL)
+    end
+
+    def address_book_url
+      self.class.const_get(:ADDRESS_BOOK_URL)
+    end
+
+    def open_http(url)
+      c = @connections[Thread.current.object_id] ||= {}
+      http = c["#{url.host}:#{url.port}"]
+      unless http
+        http = Net::HTTP.new(url.host, url.port)
+        if url.port == 443
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        c["#{url.host}:#{url.port}"] = http
+      end
+      http.start unless http.started?
+      http
+    end
+
+    def cookie_hash_from_string(cookie_string)
+      cookie_string.split(";").map{|i|i.split("=", 2).map{|j|j.strip}}.inject({}){|h,i|h[i[0]]=i[1];h}
+    end
+
+    def parse_cookies(data, existing="")
+      return existing if data.nil?
+
+      cookies = cookie_hash_from_string(existing)
+
+      data.gsub!(/ ?[\w]+=EXPIRED;/,'')
+      data.gsub!(/ ?expires=(.*?, .*?)[;,$]/i, ';')
+      data.gsub!(/ ?(domain|path)=[\S]*?[;,$]/i,';')
+      data.gsub!(/[,;]?\s*(secure|httponly)/i,'')
+      data.gsub!(/(;\s*){2,}/,', ')
+      data.gsub!(/(,\s*){2,}/,', ')
+      data.sub!(/^,\s*/,'')
+      data.sub!(/\s*,$/,'')
+
+      data.split(", ").map{|t|t.to_s.split(";").first}.each do |data|
+        k, v = data.split("=", 2).map{|j|j.strip}
+        if cookies[k] && v.empty?
+          cookies.delete(k)
+        elsif v && !v.empty?
+          cookies[k] = v
+        end
+      end
+
+      cookies.map{|k,v| "#{k}=#{v}"}.join("; ")
+    end
+
+    def remove_cookie(cookie, cookies)
+      parse_cookies("#{cookie}=", cookies)
+    end
+
+    def post(url, postdata, cookies="", referer="")
+      url = URI.parse(url)
+      http = open_http(url)
+      http_header = { "User-Agent" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0",
+        "Accept-Encoding" => "gzip",
+        "Cookie" => cookies,
+        "Referer" => referer,
+        "Content-Type" => 'application/x-www-form-urlencoded'
+      }
+      http_header.reject!{|k, v| k == 'Accept-Encoding'} if skip_gzip?
+      resp, data = http.post(url.path, postdata, http_header)
+      data = uncompress(resp, data)
+      cookies = parse_cookies(resp.response['set-cookie'], cookies)
+      forward = resp.response['Location']
+      forward ||= (data =~ /<meta.*?url='([^']+)'/ ? CGI.unescapeHTML($1) : nil)
+  if (not forward.nil?) && URI.parse(forward).host.nil?
+    forward = url.scheme.to_s + "://" + url.host.to_s + forward
+  end
+      return data, resp, cookies, forward
+    end
+
+    def get(url, cookies="", referer="")
+      url = URI.parse(url)
+      http = open_http(url)
+      resp, data = http.get("#{url.path}?#{url.query}",
+        "User-Agent" => "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0",
+        "Accept-Encoding" => "gzip",
+        "Cookie" => cookies,
+        "Referer" => referer
+      )
+      data = uncompress(resp, data)
+      cookies = parse_cookies(resp.response['set-cookie'], cookies)
+      forward = resp.response['Location']
+    if (not forward.nil?) && URI.parse(forward).host.nil?
+    forward = url.scheme.to_s + "://" + url.host.to_s + forward
+    end
+      return data, resp, cookies, forward
+    end
+
+    def uncompress(resp, data)
+      case resp.response['content-encoding']
+      when 'gzip'
+        gz = Zlib::GzipReader.new(StringIO.new(data))
+        data = gz.read
+        gz.close
+        resp.response['content-encoding'] = nil
+      # FIXME: Not sure what Hotmail was feeding me with their 'deflate',
+      #        but the headers definitely were not right
+      when 'deflate'
+        data = Zlib::Inflate.inflate(data)
+        resp.response['content-encoding'] = nil
+      end
+
+      data
+    end
+  end
+
+  class ContactsError < StandardError
+  end
+
+  class AuthenticationError < ContactsError
+  end
+
+  class ConnectionError < ContactsError
+  end
+
+  class TypeNotFound < ContactsError
+  end
+
+  def self.new(type, login, password="", secret_key="", options={})
+    if !password.nil? && password != ''  && !secret_key.nil? && secret_key != ''
+      password = Encryptor.decrypt(URI.unescape(password), :key => secret_key)
+    end
+    if TYPES.include?(type.to_s.intern)
+      TYPES[type.to_s.intern].new(login, password, options)
+    elsif FILETYPES.include?(type.to_s.intern)
+      FILETYPES[type.to_s.intern].new(login)
+    else
+      raise TypeNotFound, "#{type.inspect} is not a valid type, please choose one of the following: #{TYPES.keys.inspect} or #{FILETYPES.keys.inspect}"
+    end
+  end
+
+  def self.guess(login, password, options={})
+    TYPES.inject([]) do |a, t|
+      begin
+        a + t[1].new(login, password, options).contacts
+      rescue AuthenticationError
+        a
+      end
+    end.uniq
+  end
+end

data/lib/contacts/facebook.rb

@@ -0,0 +1,24 @@
+begin
+  require 'mini_fb'
+rescue LoadError
+  puts "Contact Gem: No mini_fb gem, so no facebook"
+else
+  class Contacts
+    class Facebook < Base
+
+      def contacts
+        return @contacts if @contacts
+      end
+
+
+      def real_connect
+        f = MiniFB.get(@password, @login, :type => "friends")
+        raise "Didn't find users" unless f.data
+        @contacts = f.data.map do |hashie| hashie.values end
+      rescue Exception => e
+        raise AuthenticationError, "Facebook authentication failed"
+      end
+    end
+    TYPES[:facebook] = Facebook
+  end
+end

data/lib/contacts/gmail.rb

@@ -0,0 +1,32 @@
+require 'gdata'
+
+class Contacts
+  class Gmail < Base
+    
+    CONTACTS_SCOPE = 'http://www.google.com/m8/feeds/'
+    CONTACTS_FEED = CONTACTS_SCOPE + 'contacts/default/full/?max-results=1000'
+    
+    def contacts
+      return @contacts if @contacts
+    end
+    
+    def real_connect
+      @client = GData::Client::Contacts.new
+      @client.clientlogin(@login, @password, @options[:captcha_token], @options[:captcha_response])
+      
+      feed = @client.get(CONTACTS_FEED).to_xml
+      
+      @contacts = feed.elements.to_a('entry').collect do |entry|
+        title, email = entry.elements['title'].text, nil
+        entry.elements.each('gd:email') do |e|
+            email = e.attribute('address').value 
+        end
+        [title, email] unless email.nil?
+      end
+      @contacts.compact!
+    rescue GData::Client::AuthorizationError => e
+      raise AuthenticationError, "Username or password are incorrect"
+    end
+  end
+  TYPES[:gmail] = Gmail
+end

data/lib/contacts/hotmail.rb

@@ -0,0 +1,122 @@
+class Contacts
+  class Hotmail < Base
+    URL                 = "https://login.live.com/login.srf?id=2"
+    OLD_CONTACT_LIST_URL = "http://%s/cgi-bin/addresses"
+    NEW_CONTACT_LIST_URL = "http://%s/mail/GetContacts.aspx"
+    CONTACT_LIST_URL = "http://mpeople.live.com/default.aspx?pg=0"
+    COMPOSE_URL         = "http://%s/cgi-bin/compose?"
+    PROTOCOL_ERROR      = "Hotmail has changed its protocols, please upgrade this library first. If that does not work, report this error at http://rubyforge.org/forum/?group_id=2693"
+    PWDPAD = "IfYouAreReadingThisYouHaveTooMuchFreeTime"
+    MAX_HTTP_THREADS    = 8
+
+    def real_connect
+      data, resp, cookies, forward = get(URL)
+      old_url = URL
+      until forward.nil?
+        data, resp, cookies, forward, old_url = get(forward, cookies, old_url) + [forward]
+      end
+
+      postdata =  "PPSX=%s&PwdPad=%s&login=%s&passwd=%s&LoginOptions=2&PPFT=%s" % [
+        CGI.escape(data.split("><").grep(/PPSX/).first[/=\S+$/][2..-3]),
+        PWDPAD[0...(PWDPAD.length-@password.length)],
+        CGI.escape(login),
+        CGI.escape(password),
+        CGI.escape(data.split("><").grep(/PPFT/).first[/=\S+$/][2..-3])
+      ]
+
+      form_url = data.split("><").grep(/form/).first.split[5][8..-2]
+      data, resp, cookies, forward = post(form_url, postdata, cookies)
+
+      old_url = form_url
+      until cookies =~ /; PPAuth=/ || forward.nil?
+        data, resp, cookies, forward, old_url = get(forward, cookies, old_url) + [forward]
+      end
+
+      if data.index("The e-mail address or password is incorrect")
+        raise AuthenticationError, "Username and password do not match"
+      elsif data != ""
+        raise AuthenticationError, "Required field must not be blank"
+      elsif cookies == ""
+        raise ConnectionError, PROTOCOL_ERROR
+      end
+
+      data, resp, cookies, forward = get("http://mail.live.com/mail", cookies)
+      until forward.nil?
+        data, resp, cookies, forward, old_url = get(forward, cookies, old_url) + [forward]
+      end
+
+      @domain = URI.parse(old_url).host
+      @cookies = cookies
+    rescue AuthenticationError => m
+      if @attempt == 1
+        retry
+      else
+        raise m
+      end
+    end
+
+    def contacts(options = {})
+      if connected?
+        url = URI.parse(contact_list_url)
+        data, resp, cookies, forward = get( contact_list_url, @cookies )
+
+        if resp.code_type != Net::HTTPOK
+          raise ConnectionError, self.class.const_get(:PROTOCOL_ERROR)
+        end
+
+        @contacts = []
+        build_contacts = []
+        go = true
+        index = 0
+
+        while(go) do
+          go = false
+          url = URI.parse(get_contact_list_url(index))
+          http = open_http(url)
+          resp, data = http.get(get_contact_list_url(index), "Cookie" => @cookies)
+
+          email_match_text_beginning = Regexp.escape("http://m.mail.live.com/?rru=compose&amp;to=")
+          email_match_text_end = Regexp.escape("&amp;")
+          raw_html = resp.body.split("\n").grep(/(?:e|dn)lk[0-9]+/)
+          raw_html.delete_at 0
+          raw_html.inject('') do |memo, row|
+            c_info = row.match(/(e|dn)lk([0-9])+/)
+
+            # Same contact, or different?
+            build_contacts << [] if memo != c_info[2]
+
+            # Grab info
+            case c_info[1]
+              when "e" # Email
+                build_contacts.last[1] = row.match(/#{email_match_text_beginning}(.*)#{email_match_text_end}/)[1]
+              when "dn" # Name
+                build_contacts.last[0] = row.match(/<a[^>]*>(.+)<\/a>/)[1]
+            end
+
+            # Set memo to contact id
+            c_info[2]
+          end
+
+          go = resp.body.include?("ContactList_next")
+          index += 1
+        end
+
+        build_contacts.each do |contact|
+          unless contact[1].nil?
+            # Only return contacts with email addresses
+            contact[1] = CGI::unescape(contact[1])
+            contact[1] = contact[1].gsub(/&amp;ru.*/, '').gsub(/%40/, '@')
+            @contacts << contact
+          end
+        end
+        
+        return @contacts
+      end
+    end
+
+    def get_contact_list_url(index)
+      "http://mpeople.live.com/default.aspx?pg=#{index}"
+    end
+  end
+  TYPES[:hotmail] = Hotmail
+end

data/lib/contacts/json_picker.rb

@@ -0,0 +1,16 @@
+if !Object.const_defined?('ActiveSupport')
+  require 'json'
+end
+
+class Contacts
+  def self.parse_json( string )
+    if Object.const_defined?('ActiveSupport') and
+       ActiveSupport.const_defined?('JSON')
+      ActiveSupport::JSON.decode( string )
+    elsif Object.const_defined?('JSON')
+      JSON.parse( string )
+    else
+      raise 'Contacts requires JSON or Rails (with ActiveSupport::JSON)'
+    end
+  end
+end

data/lib/contacts/linked_in.rb

@@ -0,0 +1,31 @@
+begin
+  require 'oauth'
+rescue LoadError
+  puts "No oauth gem, so no linked_in"
+else
+  class Contacts
+    class LinkedIn < Base
+
+      def contacts
+        return @contacts if @contacts
+      end
+
+
+      def real_connect
+        consumer = OAuth::Consumer.new(@options[:app_id], @options[:app_secret])
+        access_token = OAuth::AccessToken.new(consumer, @login, @password)
+        raw_connections = access_token.get("http://api.linkedin.com/v1/people/~/connections", 'x-li-format' => 'json').body
+        parsed_connections = JSON.parse(raw_connections)
+        raise "Didn't find users" unless parsed_connections["values"] && parsed_connections["values"].count > 0
+        contacts = parsed_connections["values"]
+
+        @contacts = contacts.map do |contact|
+          ["#{contact["firstName"]} #{contact["lastName"]}", contact["id"]]
+        end
+      rescue Exception => e
+        raise AuthenticationError, "linked_in authentication failed"
+      end
+    end
+    TYPES[:linked_in] = LinkedIn 
+  end
+end