faceoff 1.0.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-05-11
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/faceoff
+lib/faceoff.rb
+lib/faceoff/album.rb
+lib/faceoff/note.rb
+lib/faceoff/pagelet.rb
+lib/faceoff/photo.rb
+lib/faceoff/user.rb
+lib/faceoff/video.rb
+test/test_faceoff.rb

data/README.txt

@@ -0,0 +1,80 @@
+= faceoff
+
+* http://github.com/yaksnrainbows/faceoff
+
+== DESCRIPTION:
+
+A scraper to backup your facebook account (albums, photos, notes, users, video).
+Why a scraper instead of using facebook apps? Logging in as a user gives you
+access to more data and it's harder to block.
+
+
+== SYNOPSIS:
+
+Using the gem lib:
+
+  require 'faceoff'
+
+  f = Faceoff.login "email@example.com", "password"
+
+  f.photos_of_me{|p| p.save!}
+  # Saves to ./Photos\ of\ me/
+
+  f.albums[0].name
+  #=> "Album title"
+
+  f.albums[0].photos(0..10)
+  #=> [<#Photo...>,<#Photo...>, ...]
+
+  f.albums[0].photos[0].url
+  #=> "http://photo/url.jpg"
+
+  f.notes.first.title
+  #=> "Title of note"
+
+
+Using the gem bin:
+
+  faceoff --all -d path/to/dir
+  faceoff --notes --albums '1..4'
+  faceoff email@example.com password -A
+
+For more information see:
+
+  faceoff -h
+
+== REQUIREMENTS:
+
+* mechanize
+* highline
+* json
+* vpim
+
+== INSTALL:
+
+* sudo gem install faceoff
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+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,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :isolate
+
+Hoe.spec 'faceoff' do
+  developer('Jeremie Castagna', 'yaksnrainbows@gmail.com')
+
+  self.extra_deps << ['highline',  '>= 1.5.1']
+  self.extra_deps << ['mechanize', '>= 1.0.0']
+  self.extra_deps << ['json',      '>= 1.2.0']
+  self.extra_deps << ['vpim',      '0.695']
+end
+
+# vim: syntax=ruby

data/bin/faceoff

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+begin
+  require 'faceoff'
+rescue LoadError
+  $: << 'lib'
+  require 'lib/faceoff'
+end
+
+Faceoff.run ARGV

data/lib/faceoff.rb

@@ -0,0 +1,390 @@
+# Odd hack that makes the vpim-mechanize conflict disappear.
+Vpim = Module.new
+
+# Hack to fix old ruby version support of Vpim
+class Array
+  def to_str
+    self.to_s
+  end
+end
+
+
+require 'rubygems'
+require 'mechanize'
+require 'highline'
+
+require 'vpim/vcard'
+
+require 'optparse'
+require 'json'
+require 'time'
+require 'fileutils'
+
+class Faceoff
+
+  require 'faceoff/pagelet'
+  require 'faceoff/note'
+  require 'faceoff/photo'
+  require 'faceoff/album'
+  require 'faceoff/video'
+  require 'faceoff/user'
+
+
+  # Version of the gem.
+  VERSION = '1.0.0'
+
+  # Command line actions available.
+  ACTIONS = %w{albums friends notes photos_of_me profile_pictures videos_of_me}
+
+  # Default directory to save data to.
+  DEFAULT_DIR = "faceoff-#{Time.now.to_i}"
+
+
+  ##
+  # Create a new Faceoff instance and login.
+
+  def self.login email, password
+    inst = self.new email, password
+    inst.login
+    inst if inst.logged_in?
+  end
+
+
+  ##
+  # Parse ARGVs
+
+  def self.parse_args argv
+    options = {}
+
+    opts = OptionParser.new do |opt|
+      opt.program_name = File.basename $0
+      opt.version = Faceoff::VERSION
+      opt.release = nil
+
+      opt.banner = <<-STR
+Faceoff is a facebook scraper that allows you to download and backup
+your content in a reusable format.
+
+  Usage:
+    #{opt.program_name} -h/--help
+    #{opt.program_name} -v/--version
+    #{opt.program_name} [facebook_email [password]] [options...]
+
+  Examples:
+    #{opt.program_name} example@yahoo.com --all
+    #{opt.program_name} example@yahoo.com --albums '2..3'
+    #{opt.program_name} example@yahoo.com --friends --profilepics 0
+
+  Options:
+      STR
+
+      opt.on('-A', '--all', 'Retrieve all facebook data') do
+        ACTIONS.each{|a| options[a] = true }
+      end
+
+      opt.on('-a', '--albums [RANGE]', 'Retrieve albums') do |range|
+        options['albums'] = parse_range range
+      end
+
+      opt.on('-f', '--friends [RANGE]', 'Retrieve contacts') do |range|
+        options['friends'] = parse_range range
+      end
+
+      opt.on('-n', '--notes [RANGE]', 'Retrieve notes') do |range|
+        options['notes'] = parse_range range
+      end
+
+      opt.on('-p', '--photosofme [RANGE]', 'Retrieve photos of me') do |range|
+        options['photos_of_me'] = parse_range range
+      end
+
+      opt.on('-P', '--profilepics [RANGE]', 'Retrieve profile pics') do |range|
+        options['profile_pictures'] = parse_range range
+      end
+
+      opt.on('-V', '--videosofme [RANGE]', 'Retrieve videos of me') do |range|
+        options['videos_of_me'] = parse_range range
+      end
+
+      opt.on('-d', '--directory PATH', 'Directory to save to') do |path|
+        options['dir'] = path
+      end
+
+      opt.on('-z', '--gzip [NAME]', 'Zip content when done') do |name|
+        options['gzip'] = name || true
+      end
+    end
+
+    opts.parse! argv
+
+    options['dir'] ||= "."
+
+    options['email'], options['password'] = argv
+
+    options
+  end
+
+
+  ##
+  # Takes a range or number as a string and returns a range or integer.
+  # Returns true if no range or int value is found.
+
+  def self.parse_range str
+    str = str.to_s.strip
+
+    return Range.new($1.to_i, $2.to_i) if str =~ /^(\d+)\.\.(\d+)$/
+    return str.to_i if str == str.to_i.to_s
+
+    true
+  end
+
+
+  ##
+  # Run from the command line.
+
+  def self.run argv
+    options = parse_args argv
+
+    $stdin.sync
+    input = HighLine.new $stdin
+
+    faceoff = nil
+
+    until faceoff do
+      email    = options['email'] || input.ask("Facebook Email: ")
+      password = options['password'] ||
+        input.ask("Facebook Password: "){|i| i.echo = false}
+
+      faceoff = login email, password
+      options['password'] = nil unless faceoff
+    end
+
+    ACTIONS.each do |action|
+      next unless options[action]
+      dir = File.join options['dir'], action.capitalize.gsub("_", " ")
+
+      faceoff.send(action, options[action]) do |item|
+        name = item.name rescue item.fid
+        puts "Saving #{action} '#{name}'"
+        item.save! dir
+      end
+    end
+  end
+
+
+  ##
+  # Download a photo from a url. Pass a block to catch the data.
+
+  def self.download url
+    uri = URI.parse url
+
+    resp = Net::HTTP.start(uri.host) do |http|
+      http.get uri.path
+    end
+
+    resp.body
+  end
+
+
+  ##
+  # Safely save a file; rename it if name exists.
+
+  def self.safe_save filename, &block
+    dir = File.dirname(filename)
+
+    FileUtils.mkdir_p dir
+    raise "Invalid directory #{dir}" unless File.directory? dir
+
+    test_filename = filename
+
+    i = 0
+    while File.file?(test_filename)
+      i = i.next
+      ext = File.extname filename
+
+      test_filename = File.join File.dirname(filename),
+                                "#{File.basename(filename, ext)} (#{i})#{ext}"
+    end
+
+    filename = test_filename
+
+    File.open(filename, "w+") do |f|
+      block.call(f) if block_given?
+    end
+  end
+
+
+  # Mechanize agent
+  attr_accessor :agent
+
+  # User email
+  attr_accessor :email
+
+  # User password
+  attr_accessor :password
+
+  # Facebook profile id
+  attr_writer :profile_id
+
+
+  ##
+  # Instantiate with user information.
+
+  def initialize email, password
+    @email      = email
+    @password   = password
+    @profile_id = nil
+
+    @agent = Mechanize.new
+    @agent.user_agent_alias = 'Mac Safari'
+    @agent.redirect_ok = true
+
+    @albums = nil
+    @friends = nil
+    @notes = nil
+    @photos_of_me = nil
+    @profile_pics = nil
+    @videos_of_me = nil
+  end
+
+
+  ##
+  # Returns an options hash based on the type of input:
+  #   bracket_for 5
+  #   # => {:limit => 5}
+  #
+  #   bracket_for 3..5
+  #   # => {:limit => 3, :start => 3}
+  #
+  #   bracket_for true
+  #   # => {}
+
+  def bracket_for obj
+    case obj
+    when Fixnum then {:limit => obj}
+    when Range  then {:limit => obj.entries.length, :start => obj.first}
+    else {}
+    end
+  end
+
+
+  ##
+  # Check if we're logged into facebook.
+
+  def logged_in?
+    url = URI.parse("http://www.facebook.com")
+    #puts @agent.cookie_jar.cookies(url).inspect
+    @agent.cookie_jar.cookies(url).select{|c| c.name == "c_user" }.first
+  end
+
+
+  ##
+  # Login to facebook.
+
+  def login
+    page = @agent.get("http://www.facebook.com")
+    form  = page.form_with \
+      :action => 'https://login.facebook.com/login.php?login_attempt=1'
+
+    return unless form
+
+    form.email = @email
+    form.pass  = @password
+
+    page = form.submit
+    logged_in?
+  end
+
+
+  ##
+  # Returns an array of photo albums.
+
+  def albums reload=false, &block
+    return @albums if @albums && !reload
+    @albums = Album.retrieve_all self, bracket_for(reload), &block
+  end
+
+
+  ##
+  # Returns the logged in user's User object.
+
+  def user reload=false
+    return @user if @user && !reload
+    @user = User.retrieve self, profile_id
+  end
+
+
+  ##
+  # Returns an array of friends.
+
+  def friends reload=false, &block
+    if @friends && !reload
+      @friends.each &block if block_given?
+      return @friends
+    end
+
+    @friends = User.retrieve_all self, bracket_for(reload), &block
+  end
+
+
+  ##
+  # Returns an array of notes.
+
+  def notes reload=false, &block
+    if @notes && !reload
+      @notes.each &block if block_given?
+      return @notes
+    end
+
+    @notes = Note.retrieve_all self, bracket_for(reload), &block
+  end
+
+
+  ##
+  # Returns an array of photos of me.
+
+  def photos_of_me reload=false, &block
+    if @photos_of_me && !reload
+      @photos_of_me.each &block if block_given?
+      return @photos_of_me
+    end
+
+    @photos_of_me = Photo.photos_of_me self, bracket_for(reload), &block
+  end
+
+
+  ##
+  # Returns an array of profile pictures photos.
+
+  def profile_pictures reload=false, &block
+    if @profile_pics && !reload
+      @profile_pics.each &block if block_given?
+      return @profile_pics
+    end
+
+    @profile_pics =
+      Photo.photos_of_album self, :profile, bracket_for(reload), &block
+  end
+
+
+  ##
+  # Returns the facebook profile id. Fetches it from the page if not set.
+
+  def profile_id reload=false
+    return @profile_id if @profile_id && !reload
+    @profile_id = $1 if @agent.current_page.body =~ /\\"user\\":(\d+)/m
+  end
+
+
+  ##
+  # Returns an array of videos of me.
+
+  def videos_of_me reload=false, &block
+    if @videos_of_me && !reload
+      @videos_of_me.each &block if block_given?
+      return @videos_of_me
+    end
+
+    @videos_of_me = Video.videos_of_me self, bracket_for(reload), &block
+  end
+end

data/lib/faceoff/album.rb

@@ -0,0 +1,83 @@
+class Faceoff
+
+  class Album
+
+
+    ##
+    # Returns an array of albums for the current user. Pass the :user_id option
+    # to override the logged in user.
+
+    def self.retrieve_all faceoff, options={}, &block
+      albums = []
+      limit  = options[:limit]
+      start  = options[:start] || 0
+
+      agent   = faceoff.agent
+      user_id = options[:user_id] || faceoff.profile_id
+
+      page = agent.get "/photos.php?id=#{user_id}"
+
+      xpath = "table[@class='uiGrid fbPhotosGrid']/tbody/"+
+              "/div[@class='pls photoDetails']/a"
+
+      nodes = page.search(xpath)
+
+      limit ||= nodes.length
+
+      nodes[start, limit].each do |node|
+        album_id   = $1 if node['href'] =~ /aid=(\d+)/
+        album_name = node.text
+
+        albums << new(faceoff, album_id, album_name)
+
+        yield albums.last if block_given?
+      end
+
+      albums
+    end
+
+
+    # Facebook album id.
+    attr_accessor :fid
+
+    # Name of the album.
+    attr_accessor :name
+
+
+    def initialize faceoff, id, name
+      @faceoff = faceoff
+      @agent   = faceoff.agent
+
+      @fid    = id
+      @name   = name
+      @photos = nil
+    end
+
+
+    ##
+    # Returns an array of photos.
+
+    def photos reload=false, &block
+      if @photos && !reload
+        @photos.each &block if block_given?
+        return @photos
+      end
+
+      options = {}
+      options[:limit] = reload if Fixnum === reload
+
+      @photos = Photo.photos_of_album @faceoff, @fid, options, &block
+    end
+
+
+    ##
+    # Save the album to the provided directory.
+
+    def save! target="./Albums"
+      dirname = File.join target, @name
+      FileUtils.mkdir_p dirname
+
+      self.photos{|p| p.save! dirname}
+    end
+  end
+end

data/lib/faceoff/note.rb

@@ -0,0 +1,100 @@
+class Faceoff
+
+  class Note
+
+    CONTENT_CLASSES = "note_content text_align_ltr direction_ltr clearfix"
+
+    ##
+    # Returns an array of notes.
+
+    def self.retrieve_all faceoff, options={}, &block
+      agent = faceoff.agent
+      limit = options[:limit]
+      start = options[:start] || 0
+
+      note_count = limit
+      index = start
+
+      notes = []
+      page  = agent.current_page
+
+      while !limit || notes.length < limit && page.link_with(:text => "Next") do
+        notes = notes.concat notes_at_index(faceoff, index, &block)
+        page  = agent.current_page
+        index = start + notes.length
+
+        last_link = page.link_with(:text => 'Last')
+        limit ||= $1.to_i + 10 if
+          last_link && last_link.href =~ %r{/notes.php\?id=\d+&start=(\d+)}
+        limit ||= 10
+      end
+
+      notes[0..(limit-1)]
+    end
+
+
+    ##
+    # Get notes on one page starting at a note index.
+
+    def self.notes_at_index faceoff, index, &block
+      agent = faceoff.agent
+      page  = agent.get "/notes.php?id=#{faceoff.profile_id}&start=#{index}"
+
+      notes = []
+
+      page.search("div[@class='note_body']").each do |div|
+        title_link = div.search("div[@class='note_title']/a").first
+        id    = $1 if title_link['href'] =~ %r{/note\.php\?note_id=(\d+)}
+        title = title_link.text
+        date  = Time.parse div.search("div[@class='byline']").first.text
+        body  = div.search("div[@class='#{CONTENT_CLASSES}']/div").first.text
+
+        notes << new(id, title, body, date)
+        yield notes.last if block_given?
+      end
+
+      notes
+    end
+
+
+    # Facebook id of the note.
+    attr_accessor :fid
+
+    # Note title.
+    attr_accessor :title, :name
+
+    # Note contents.
+    attr_accessor :body
+
+    # Date note was created at.
+    attr_accessor :date
+
+
+    def initialize id, title, body, date=nil
+      @fid   = id
+      @title = @name = title
+      @body  = body
+      @date  = date || Time.now
+    end
+
+
+    ##
+    # Saves the note to the provided file path.
+
+    def save! target="./Notes"
+      filename = File.join(target, "#{@title}.txt")
+
+      Faceoff.safe_save(filename) do |file|
+        file.write self.to_s
+      end
+    end
+
+
+    ##
+    # Returns the object as a string with title, date, and body.
+
+    def to_s
+      "#{@title}\n#{@date.to_s}\n\n#{@body}"
+    end
+  end
+end

data/lib/faceoff/pagelet.rb

@@ -0,0 +1,44 @@
+class Faceoff
+
+  ##
+  # The pagelet class is used to parse out facebook javascript dynamic content
+  # on a given html page.
+
+  class Pagelet
+
+    ##
+    # Parses an html string and returns a hash of
+    # Nokogiri::HTML::Document objects, indexed by page area:
+    #   Pagelet.parse html
+    #   #=> {:profile_photo => <#OBJ>, :top_bar => <#OBJ>...}
+    #
+    #   Pagelet.parse html, :profile_photo
+    #   #=> <#OBJ>
+
+    def self.parse html, type=nil
+      pagelet = nil
+
+      matches = html.scan regex_for(type)
+
+      matches.each do |name, html|
+        html     = JSON.parse("[\"#{html}\"]").first
+        html_doc = Nokogiri::HTML.parse html
+        return html_doc if type
+
+        pagelet ||= {}
+        pagelet[name.to_sym] = html_doc
+      end
+
+      pagelet
+    end
+
+
+    ##
+    # Returns a regex to retrieve the given pagelet.
+
+    def self.regex_for name
+      name ||= "\\w+"
+      %r{<script>.*"pagelet_(#{name})":"(.*)"\},"page_cache":.*\}\);</script>}
+    end
+  end
+end

data/lib/faceoff/photo.rb

@@ -0,0 +1,128 @@
+class Faceoff
+
+  class Photo
+
+
+    ##
+    # Retrieve all 'Photos of Me'.
+
+    def self.photos_of_me faceoff, options={}, &block
+      agent = faceoff.agent
+      start = options[:start] || 0
+
+      index = start % 15
+
+      param = "id=#{faceoff.profile_id}&v=photos&so=#{start}&ref=sgm"
+
+      page = agent.get "/profile.php?#{param}"
+
+      photo_id, options[:user_id] =
+        page.body.scan(%r{/photo.php\?pid=(\d+)[^\\]+;id=(\d+)})[index]
+
+      return unless photo_id
+
+      retrieve_all faceoff,
+                   photo_id,
+                   options.merge(:album => "Photos of me"),
+                   &block
+    end
+
+
+    ##
+    # Retrieve all photos for a given album id. To retrieve the profile
+    # album pass :profile as the album_id.
+
+    def self.photos_of_album faceoff, album_id, options={}, &block
+      agent = faceoff.agent
+      start = options[:start] || 0
+
+      options[:album] = "Profile pictures" if album_id == :profile
+
+      param = album_id == :profile ? "profile=1" : "aid=#{album_id}"
+      param = "#{param}&id=#{faceoff.profile_id}&s=#{start}"
+
+      page = agent.get "/album.php?#{param}"
+      photo_link = page.link_with(:href => %r{/photo.php}).href
+      photo_id = $1 if photo_link =~ /pid=(\d+)/
+
+      return unless photo_id
+
+      retrieve_all faceoff, photo_id, options, &block
+    end
+
+
+    ##
+    # Retrieve all photos in an album, starting at a given photo id.
+    # Setting the 'global' argument to true will attempt to retrieve all
+    # 'Photos of Me'.
+
+    def self.retrieve_all faceoff, photo_id, options={}, &block
+      agent  = faceoff.agent
+      user_id = options[:user_id]
+      limit  = options[:limit]
+
+      param = "pid=#{photo_id}&id=#{user_id || faceoff.profile_id}"
+      param = "#{param}&view=global&subj=#{faceoff.profile_id}" if user_id
+
+      page = agent.get "/photo.php?#{param}"
+
+      photo_count = ($1.to_i - 1) if page.body =~ /Photo \d+ of (\d+)/m
+      photo_count = limit if limit && photo_count > limit
+
+      photos = []
+
+      photo_count.times do |i|
+        url = page.search("img[@id='myphoto']").first['src']
+        photo_id = $1 if page.uri.query =~ %r{pid=(\d+)}
+
+        caption =
+          page.search("div[@class='photocaption_text']").first.text rescue nil
+
+        photos << new(photo_id, url, :caption => caption,
+                                     :album => options[:album])
+
+        yield photos.last if block_given?
+
+        page = page.link_with(:text => 'Next').click
+      end
+
+      photos
+    end
+
+
+    # Facebook photo id.
+    attr_accessor :fid
+
+    # Url of the photo.
+    attr_accessor :url
+
+    # Caption of the photo.
+    attr_accessor :caption
+
+    # Album name (context) of the photo.
+    attr_accessor :album
+
+
+    def initialize id, url, options={}
+      @fid     = id
+      @url     = url
+      @caption = options[:caption]
+      @album   = options[:album] || "Photos"
+    end
+
+
+    ##
+    # Saves the photo to the provided file path.
+
+    def save! target=nil
+      target ||= File.join ".", @album
+      filename = File.join(target, "#{@fid}#{File.extname(@url)}")
+
+      data = Faceoff.download(@url)
+
+      Faceoff.safe_save(filename) do |file|
+        file.write data
+      end
+    end
+  end
+end

data/lib/faceoff/user.rb

@@ -0,0 +1,216 @@
+class Faceoff
+
+  class User
+
+    IM_SERVICES = ['AIM', 'Yahoo', 'Skype', 'Google Talk', 'Windows Live',
+      'Gadu-Gadu', 'QQ', 'ICQ', 'Yahoo Japan', 'NateOn']
+
+
+    ##
+    # Retrieve all friends of the given faceoff user.
+
+    def self.retrieve_all faceoff, options={}
+      agent = faceoff.agent
+      limit = options[:limit]
+      start = options[:start] || 0
+
+      page = agent.get "/friends/ajax/superfriends.php?"+
+        "__a=1&filter=afp&type=afp&value&is_pagelet=false&offset=0"
+
+      user_ids = JSON.parse $1 if page.body =~ %r{"members":(\[[^\]]+\])}
+      limit ||= user_ids.length
+
+      user_ids[start, limit].map do |uid|
+        user = retrieve faceoff, uid
+        yield user if block_given?
+        user
+      end
+    end
+
+
+    ##
+    # Retrieve a single user based on the user's id or alias:
+    #   User.retrieve f, 12345
+    #   User.retrieve f, 'bob.smith'
+
+    def self.retrieve faceoff, user_id
+      agent = faceoff.agent
+
+      path = if user_id =~ /^\d+$/
+               "/profile.php?id=#{user_id}&v=info&ref=sgm"
+             else
+               "/#{user_id}?v=info"
+             end
+
+      page = agent.get path
+
+      pagelets = Pagelet.parse page.body
+
+      name = pagelets[:top_bar].css("h1#profile_name").first.text
+      id   = $1 if
+        pagelets[:top_bar].css("a#top_bar_pic").first['href'] =~
+        %r{/profile\.php\?id=(\d+)}
+
+
+      user = User.new id, name
+
+      details = pagelets[:tab_content]
+
+      birthday = fattr(details, 'Birthday')[0].strip
+      user.birthday = Time.parse birthday if birthday && !birthday.empty?
+
+      user.emails = fattr details, 'Email'
+
+      user.phones['mobile'] =
+        fattr(details, 'Mobile Number').first.gsub(/[^\da-z]/i, '') rescue nil
+
+      user.phones['main'] =
+        fattr(details, 'Phone').first.gsub(/[^\da-z]/i, '') rescue nil
+
+
+      user.photo = pagelets[:profile_photo].css("img#profile_pic").first['src']
+
+      user.address = {}
+      user.address[:street] = fattr(details, "Address", :href => /&a2=/).first
+
+      user.address[:city], user.address[:state] =
+        fattr(details, "Address", :href => /&c2=/).first.to_s.split(", ")
+
+      user.address[:state], user.address[:country] =
+        [nil, user.address[:state]] if user.address[:state].to_s.length > 2
+
+      user.address[:zip] = fattr(details, "Address", :href => /&z2=/).first
+
+
+      IM_SERVICES.each do |im|
+        im_alias = fattr(details, im).first
+        next unless im_alias
+        user.aliases[im] = im_alias
+      end
+
+      user.aliases['Facebook'] = $1 if
+        fattr(details, 'Facebook Profile').first =~ /([^\/]+)$/
+
+      user
+    end
+
+
+    ##
+    # Get a facebook attribute from a given Nokogiri::HTML::Document.
+
+    def self.fattr doc, attrib, options={}
+      resp  = []
+
+      nodes = doc.search("th[@class='label'][text()='#{attrib}:']")
+
+      return resp if nodes.empty?
+
+      nodes.first.next.children.each do |node|
+        text = node.name == "img" ? node['src'] : node.text.strip
+        next if text.empty?
+
+        if options.empty?
+          resp << text
+        else
+          options.each do |key, matcher|
+            resp << text if node[key] =~ matcher
+          end
+        end
+      end
+
+      resp
+    end
+
+
+    # Facebook user id.
+    attr_accessor :fid
+
+    # User's name.
+    attr_accessor :name
+
+    # User's birthday.
+    attr_accessor :birthday
+
+    # Facebook profile image.
+    attr_accessor :photo
+
+    # All emails.
+    attr_accessor :emails
+
+    # Instant message aliases.
+    attr_accessor :aliases
+
+    # Phone numbers.
+    attr_accessor :phones
+
+    # Current address.
+    attr_accessor :address
+
+
+    def initialize id, name
+      @fid  = id
+      @name = name
+
+      @photo   = nil
+      @phones  = {}
+      @emails  = []
+      @aliases = {}
+      @address = {}
+    end
+
+
+    ##
+    # Saves the user as a vcard to the provided file path.
+
+    def save! target="./Contacts", vcard=nil
+      vcard = to_vcard vcard
+
+      Faceoff.safe_save(File.join(target, "#{@name}.vcf")) do |file|
+        file.write vcard
+      end
+    end
+
+
+    ##
+    # Returns a Vpip::Vcard object.
+
+    def to_vcard vcard=nil
+      vcard ||= Vpim::Vcard.create
+
+      vcard.make do |maker|
+
+        maker.name{|n| n.fullname = @name }
+
+        maker.add_field Vpim::DirectoryInfo::Field.create('BDAY',
+          @birthday.strftime("%Y-%m-%d"))
+
+        maker.add_addr do |addr|
+          addr.region   = address[:state]
+          addr.locality = address[:city]
+          addr.street   = address[:street]
+          addr.country  = address[:country]
+          addr.postalcode = address[:zip]
+        end
+
+        emails.each{|email| maker.add_email email }
+
+        phones.each do |type, number|
+          next unless number
+          maker.add_tel(number){|tel| tel.location = [type] }
+        end
+
+        aliases.each do |name, value|
+          maker.add_field Vpim::DirectoryInfo::Field.create("X-#{name}", value)
+        end
+
+        maker.add_photo do |photo|
+          photo.image = Faceoff.download @photo
+          photo.type  = File.extname(@photo)[1..-1]
+        end if @photo
+      end
+
+      vcard
+    end
+  end
+end
+

data/lib/faceoff/video.rb

@@ -0,0 +1,82 @@
+class Faceoff
+
+  class Video
+
+    TITLE_REG = /"video_title", "([^"]+)"/m
+    SRC_REG   = /"video_src", "([^"]+)"/m
+    ID_REG    = /"video_id", "([^"]+)"/m
+
+    ##
+    # Retrieve all 'Videos of Me'.
+
+    def self.retrieve_all faceoff, options={}, &block
+      agent = faceoff.agent
+      limit = options[:limit]
+      start = options[:start] || 0
+
+      page = agent.get "/video/?of=#{faceoff.profile_id}&s=#{start}"
+      summary = page.search("div[@class='summary']").first.text
+      video_count = ($2.to_i - 1) if summary =~ /(of|all) (\d+) videos/
+      video_count = limit if limit && video_count > limit
+
+      page = page.link_with(:href => %r{/video.php}).click
+
+      videos = []
+
+      video_count.times do |i|
+        video_title = URI.decode($1.gsub('+', ' ')) if page.body =~ TITLE_REG
+        video_src   = URI.decode($1) if page.body =~ SRC_REG
+        video_id    = URI.decode($1) if page.body =~ ID_REG
+
+        videos << new(video_id, video_src, video_title)
+        yield videos.last if block_given?
+
+        next_link = page.link_with(:text => 'Next')
+        break unless next_link
+
+        page = next_link.click
+      end
+
+      videos
+    end
+
+
+    ##
+    # Alias for Video::retrieve_all
+
+    def self.videos_of_me faceoff, options={}, &block
+      retrieve_all faceoff, options, &block
+    end
+
+
+    # Facebook video id.
+    attr_accessor :fid
+
+    # Url of the video.
+    attr_accessor :url
+
+    # Name of the video.
+    attr_accessor :name
+
+
+    def initialize id, url, name
+      @fid  = id
+      @url  = url
+      @name = name
+    end
+
+
+    ##
+    # Saves the video the the provided path.
+
+    def save! target="./Videos of me"
+      filename = File.join(target, "#{@name}#{File.extname(@url)}")
+
+      data = Faceoff.download(@url)
+
+      Faceoff.safe_save(filename) do |file|
+        file.write data
+      end
+    end
+  end
+end

data/test/test_faceoff.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "faceoff"
+
+class TestFaceoff < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: faceoff
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jeremie Castagna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: vpim
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 695
+        version: "0.695"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 3
+        version: 2.3.3
+  type: :development
+  version_requirements: *id005
+description: |-
+  A scraper to backup your facebook account (albums, photos, notes, users, video).
+  Why a scraper instead of using facebook apps? Logging in as a user gives you
+  access to more data and it's harder to block.
+email: 
+- yaksnrainbows@gmail.com
+executables: 
+- faceoff
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/faceoff
+- lib/faceoff.rb
+- lib/faceoff/album.rb
+- lib/faceoff/note.rb
+- lib/faceoff/pagelet.rb
+- lib/faceoff/photo.rb
+- lib/faceoff/user.rb
+- lib/faceoff/video.rb
+- test/test_faceoff.rb
+has_rdoc: true
+homepage: http://github.com/yaksnrainbows/faceoff
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: faceoff
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A scraper to backup your facebook account (albums, photos, notes, users, video)
+test_files: 
+- test/test_faceoff.rb