pidgin2adium 0.0.1

data/bin/pidgin2adium_logs

@@ -0,0 +1,67 @@
+#!/usr/bin/ruby -w
+
+=begin
+Author: Gabe Berke-Williams, 2008
+This is the shell script, which is a wrapper around Pidgin2Adium::Logs.
+Call it like so:
+<tt>pidgin2adium_logs.rb -i ~/in_logs/ -o ~/out_logs/ -l AIM.myscreenname -a me,screenname,my_pidgin_alias,other_pidgin_alias</tt>
+For <tt>-a/--aliases</tt>, there is no need to use spaces or capitalization, since spaces will be stripped out and the aliases will
+be lowercased anyway.
+=end
+
+require 'pidgin2adium/logs'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+    opts.banner = "Usage: #{File.basename($0)} [options]"
+    opts.on('-i IN_DIR', '--in IN_DIR', 'Specify directory where pidgin logs are stored') do |v|
+	options[:in] = v
+    end
+    opts.on('-o OUT_DIR', '--out OUT_DIR', 'Specify directory where Adium logs will be stored (not the Adium directory in ~/Library') do |out|
+	options[:out] = out
+    end
+    opts.on('-l LIBRARY_DIR', '--libdir LIBRARY_DIR',
+	    'Specify dirname where Adium logs are stored (eg "AIM.<username>" for',
+	    '~/Library/Application Support/Adium 2.0/Users/Default/Logs/AIM.<username>') do |ld|
+	options[:libdir] = ld
+    end
+    opts.on('-d', '--debug', 'Turn debug on.') do |lf|
+	options[:debug] = true
+    end
+    opts.on("--time-zone [TIME ZONE]",
+	    "Set time zone like \"EST\". Defaults to local time zone: #{Time.now.zone}") do |tz|
+	options[:timezone] = tz
+    end
+    opts.on('-a MY_ALIASES_AND_SNs', "--aliases MY_ALIASES_AND_SNs",
+	    "A comma-separated list of your aliases and screenname(s) so this script knows which person in a chat is you.",
+	    "Whitespace is removed and aliases are lowercased.") do |aliases|
+	options[:aliases] = aliases.split(',')
+    end
+    opts.on_tail("-h", "--help", "Show this message") do
+	puts opts
+	exit
+    end
+end.parse!
+
+need_opts = false
+required_opts = [[:i, :in], [:o, :out], [:l, :libdir], [:a, :aliases]]
+required_opts.each do |short, long|
+    if options.has_key?(short) or options.has_key?(long)
+	next
+    else
+	need_opts = true
+	puts "Required option -#{short}/--#{long} missing."
+    end
+end
+exit 1 if need_opts
+
+log_converter  =  Pidgin2Adium::Logs.new(src=options[:in],
+					 out = options[:out],
+					 aliases = options[:aliases],
+					 libdir = options[:libdir],
+					 tz = options[:timezone],
+					 debug = options[:debug]
+					)
+
+log_converter.start

data/bin/pidgin2adium_status

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+# Shell script wrapper for Pidgin2Adium::Status
+
+require 'pidgin2adium/status'
+
+xml_file = ARGV[0]
+
+unless File.readable?(xml_file)
+    puts "XML file (#{xml_file}) is not readable. Exiting."
+    exit 1
+end
+
+status_converter = Pidgin2Adium::Status.new(xml_file)
+status_converter.start

data/lib/pidgin2adium/ChatFileGenerator.rb

@@ -0,0 +1,243 @@
+# ADD DOCUMENTATION
+require 'pidgin2adium/balance-tags.rb'
+require 'hpricot'
+
+module Pidgin2Adium
+    def Pidgin2Adium.normalizeBodyEntities!(body)
+	# Convert '&' to '&' only if it's not followed by an entity.
+	body.gsub!(/&(?!lt|gt|amp|quot|apos)/, '&')
+	# replace single quotes with '&apos;' but only outside <span>s.
+	parts = body.split(/(<\/?span.*?>)/)
+	body = parts.map{ |part| part.match(/<\/?span/) ? part : part.gsub("'", '&apos;') }.join('')
+    end
+    
+    def Pidgin2Adium.normalizeBody!(body, aliasStr)
+	# Fix mismatched tags.
+	body = Pidgin2Adium.balance_tags(body)
+	normalizeBodyEntities!(body)
+	if aliasStr[0,3] == '***'
+	    # "***<alias>" is what pidgin sets as the alias for a /me action
+	    aliasStr.slice!(0,3)
+	    body = '*' + body + '*'
+	end
+	body = '<div><span style="font-family: Helvetica; font-size: 12pt;">' +
+		body +
+		'</span></div>'
+    end
+
+    class ChatFileGenerator
+	def initialize(service, mySN, otherPersonsSN, chatTimePidgin_start, tzOffset, masterAlias, destDirBase)
+	    # basicTimeInfo is for files that only have the full timestamp at
+	    # the top; we can use it to fill in the minimal per-line timestamps.
+	    # It has only 3 elements ([year, month, dayofmonth]) because
+	    # you should be able to fill everything else in.
+	    # If you can't, something's wrong.
+	    @basicTimeInfo = nil
+	    # @chatMessage is a 2D array composed of arrays like so (e.g.):
+	    # ['time'=>'2:23:48 PM', 'alias'=>'Me', 'status' => 'available', 'body'=>'abcdefg', auto-reply=true]
+	    @chatMessage=[]
+	    # chatTimeAdium_start format: YYYY-MM-DD\THH.MM.SS[+-]TZ_HRS like so:
+	    # 2008-10-05T22.26.20-0800
+	    @chatTimeAdium_start=nil
+	    @chatTimePidgin_start=chatTimePidgin_start
+	    @destDirBase=destDirBase
+	    @masterAlias=masterAlias
+	    @mySN=mySN
+	    @otherPersonsSN=otherPersonsSN
+	    @service=service
+	    @tzOffset=tzOffset
+	    # key is for Pidgin, value is for Adium
+	    # Just used for <service>.<screenname> in directory structure
+	    @SERVICE_NAME_MAP={'aim'=>'AIM',
+		'jabber'=>'jabber',
+		'gtalk'=>'GTalk',
+		'icq' => 'ICQ',
+		'qq'=>'QQ',
+		'msn'=>'MSN',
+		'yahoo'=>'Yahoo'}
+	end
+
+	def convert()
+	    initChatTime()
+	    return buildDomAndOutput()
+	end
+
+	def initChatTime()
+	    #  ParseDate.parsedate "Tuesday, July 5th, 2007, 18:35:20 UTC"
+	    #  # => [2007, 7, 5, 18, 35, 20, "UTC", 2]
+	    # [year, month, day of month, hour, minute, sec, timezone, day of week] 
+	    # strtotime returns seconds since the epoch
+	    @chatTimeAdium_start = createAdiumDate(@chatTimePidgin_start)
+	    @basicTimeInfo = ParseDate.parsedate(@chatTimePidgin_start)[0..2]
+	end
+
+	# Add a line to @chatMessage.
+	# It is its own method because attr_writer creates the method 'chatMessage=', which doesn't help for chatMessage.push
+	def appendLine(line)
+	    @chatMessage.push(line)
+	end
+
+	# 
+	def createAdiumDate(date)
+	    epochSecs = getEpochSeconds(date)
+	    if @tzOffset.nil?
+		Pidgin2Adium.logMsg("@tzOffset is nil. This really shouldn't happen.", true)
+		@tzOffset = "+0"
+	    end
+	    return Time.at(epochSecs).strftime("%Y-%m-%dT%H.%M.%S#{@tzOffset}")
+	end
+
+	def getEpochSeconds(timestr)
+	    parsed_date = ParseDate.parsedate(timestr)
+	    [0, 1, 2].each do |i|
+		parsed_date[i] = @basicTimeInfo[i] if parsed_date[i].nil?
+	    end
+	    return Time.local(*parsed_date).tv_sec
+	end
+
+	def getScreenNameByAlias(aliasStr)
+	    myAliasStr = aliasStr.clone
+	    myAliasStr.slice!(0,3) if myAliasStr[0,3] == '***'
+	    if aliasStr==""
+		return ""
+	    else
+		return @masterAlias.include?(myAliasStr.downcase.gsub(/\s*/, '')) ? @mySN : @otherPersonsSN
+	    end
+	end
+
+	# returns path of output file
+	def buildDomAndOutput()
+	    serviceName = @SERVICE_NAME_MAP[@service.downcase]
+	    destDirReal = File.join(@destDirBase, "#{serviceName}.#{@mySN}", @otherPersonsSN, "#{@otherPersonsSN} (#{@chatTimeAdium_start}).chatlog")
+	    FileUtils.mkdir_p(destDirReal)
+	    destFilePath = destDirReal + '/' + "#{@otherPersonsSN} (#{@chatTimeAdium_start}).xml"
+	    if File.exist?(destFilePath)
+		return Pidgin2Adium::Logs::FILE_EXISTS
+	    end
+
+	    # no \n before </chat> because {body} has it already
+	    chatLogTemplate = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+		"<chat xmlns=\"http://purl.org/net/ulf/ns/0.4-02\" account=\"#{@mySN}\" service=\"#{serviceName}\">\n{body}</chat>"
+
+	    allMsgs = ""
+	    @chatMessage.each do |msg|
+		# template is set to a copy of one of the three templates, 
+		# the {...} vars are subbed, and then it's added to allMsgs
+		template = nil
+		# Note:
+		# away/auto message has both body and status set
+		# pure status has status but not body set
+		# pure message has body set but not status
+		begin
+		    chatTimeAdium = createAdiumDate(msg['time'])
+		rescue TypeError => bang
+		    puts '*' * 80
+		    @chatMessage.each { |m| p m }
+		    puts "Oops! Time error! on msg:"
+		    p msg
+		    puts "Rest of message is above, just below the stars."
+		    return false
+		end
+		sender = getScreenNameByAlias(msg['alias'])
+		time = chatTimeAdium
+		aliasStr = msg['alias']
+		if msg['body']
+		    body = msg['body']
+		    if msg['status'].nil?
+			# Body with no status
+			if msg['auto-reply'] == true
+			    # auto-reply from away message
+			    template = AutoReplyMessage.new(sender, time, aliasStr, body)
+			else
+			    # pure regular message
+			    template = XMLMessage.new(sender, time, aliasStr, body)
+			end
+		    else 
+			# Body with status message
+			template = AwayMessage.new(sender, time, aliasStr, body)
+		    end
+		elsif msg['status']
+		    # Status message, no body
+		    template = StatusMessage.new(sender, time, aliasStr, msg['status'])
+		else
+		    Pidgin2Adium.logMsg("msg has neither status nor body key set. Unsure what to do. msg is as follows:", true)
+		    Pidgin2Adium.logMsg(sprintf('%p', msg), true)
+		    return false
+		end
+		begin
+		    allMsgs += template.getOutput()
+		rescue TypeError => bang
+		    Pidgin2Adium.logMsg "TypeError: #{bang.message}"
+		    Pidgin2Adium.logMsg "This is probably caused by an unrecognized status string."
+		    Pidgin2Adium.logMsg "Go to the file currently being worked on (displayed above) at time #{msg['time']}"
+		    Pidgin2Adium.logMsg "and add the status message there to one of the hashes in SrcHtmlFileParse.getAliasAndStatus."
+		    Pidgin2Adium.logMsg "**Debug info**"
+		    Pidgin2Adium.logMsg "msg: #{msg.inspect}"
+		    Pidgin2Adium.logMsg "--"
+		    Pidgin2Adium.logMsg "Exiting."
+		    return false
+		end
+	    end
+	    ret = chatLogTemplate.sub("{body}", allMsgs)
+	    # xml is ok.
+
+	    # we already checked to see if the file previously existed.
+	    outfile = File.new(destFilePath, 'w')
+	    outfile.puts(ret)
+	    outfile.close
+	    return destFilePath
+	end
+
+	# A holding object for each line of the chat.
+	# It is subclassed as appropriate (eg AutoReplyMessage).
+	# All Messages have senders, times, and aliases.
+	class Message
+	    def initialize(sender, time, aliasStr)
+		@sender = sender
+		@time = time
+		@aliasStr = aliasStr
+	    end
+	end
+
+	# Basic message with body text (as opposed to pure status messages which have no body).
+	class XMLMessage < Message
+	    def initialize(sender, time, aliasStr, body)
+		super(sender, time, aliasStr)
+		@body = Pidgin2Adium.normalizeBody!(body, @aliasStr)
+	    end
+
+	    def getOutput
+		return sprintf('<message sender="%s" time="%s" alias="%s">%s</message>' + "\n",
+			       @sender, @time, @aliasStr, @body)
+	    end
+
+	end
+
+	# An auto reply message, meaning it has a body.
+	class AutoReplyMessage < XMLMessage
+	    def getOutput
+		return sprintf('<message sender="%s" time="%s" alias="%s" auto="true">%s</message>' + "\n",
+			       @sender, @time, @aliasStr, @body)
+	    end
+	end
+
+	class AwayMessage < XMLMessage
+	    def getOutput
+		return sprintf('<status type="away" sender="%s" time="%s" alias="%s">%s</status>' + "\n",
+			       @sender, @time, @aliasStr, @body)
+	    end
+	end
+
+	# A message saying e.g. "Blahblah has gone away."
+	class StatusMessage < Message
+	    def initialize(sender, time, aliasStr, status)
+		super(sender, time, aliasStr)
+		@status = status
+	    end
+	    def getOutput
+		return sprintf('<status type="%s" sender="%s" time="%s" alias="%s"/>' + "\n",
+			       @status, @sender, @time, @aliasStr)
+	    end
+	end
+    end
+end

data/lib/pidgin2adium/SrcFileParse.rb

@@ -0,0 +1,280 @@
+# =SrcFileParse
+# The class SrcFileParse has two subclasses, SrcTxtFileParse and SrcHtmlFileParse
+# It parses the file passed into it and extracts the following
+# from each line in the chat: time, alias, and message and/or status.
+module Pidgin2Adium
+    # The two subclasses of SrcFileParse,
+    # SrcTxtFileParse and SrcHtmlFileParse, only differ
+    # in that they have their own @line_regex, @line_regex_status,
+    # and most importantly, createMsgData, which takes the
+    # +MatchData+ objects from matching against @line_regex and
+    # fits them into hashes.
+    class SrcFileParse
+	def initialize(srcPath, destDirBase, masterAlias, userTZ, userTZOffset)
+	    @srcPath = srcPath
+	    # these two are to pass to chatFG in parseFile
+	    @destDirBase = destDirBase
+	    @masterAlias = masterAlias
+	    @userTZ = userTZ
+	    @userTZOffset = userTZOffset
+	    # Automagically does grouping for you. Will be inserted in @line_regex{,_status}
+	    @timestamp_regex_str = '\(((?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{1,2}:\d{1,2}(?: .{1,2})?)\)'
+	    # the first line is special: it tells us
+	    # 1) who we're talking to 
+	    # 2) what time/date
+	    # 3) what SN we used
+	    # 4) what protocol (AIM, jabber...)
+	    @first_line_regex = /Conversation with (.*?) at (.*?) on (.*?) \((.*?)\)/s
+	end
+
+	# Takes the body of a line of a chat and returns the [username, status] as a 2-element array.
+	# Example:
+	# Pass in "Generic Screenname228 has signed off" and it returns <tt>["Generic Screenname228", "offline"]</tt>
+	def getAliasAndStatus(str)
+	    alias_and_status = [nil, nil]
+
+	    # Screen name is in regex group 1.
+	    status_map = {
+		/(.+) logged in\.$/ => 'online',
+		/(.+) logged out\.$/ => 'offline',
+		/(.+) has signed on\.$/ => 'online',
+		/(.+) has signed off\.$/ => 'offline',
+		/(.+) has gone away\.$/ => 'away',
+		/(.+) is no longer away\.$/ => 'available',
+		/(.+) has become idle\.$/ => 'idle',
+		/(.+) is no longer idle\.$/ => 'available',
+		# file transfer
+		/Starting transfer of .+ from (.+)/ => 'file-transfer-start',
+		/^Offering to send .+ to (.+)$/ => 'fileTransferRequested',
+		/(.+) is offering to send file/ => 'fileTransferRequested',
+	    }
+
+	    # statuses that come from my end. I totally made up these status names.
+	    my_status_map = {
+		# encryption
+		/^Received message encrypted with wrong key$/ => 'encrypt-error',
+		/^Requesting key\.\.\.$/ => 'encrypt-error',
+		/^Outgoing message lost\.$/ => 'encrypt-error',
+		/^Conflicting Key Received!$/ => 'encrypt-error',
+		/^Error in decryption- asking for resend\.\.\.$/ => 'encrypt-error',
+		/^Making new key pair\.\.\.$/ => 'encrypt-key-create',
+		# file transfer - these are in this (non-used) list because you can't get the alias out of matchData[1]
+		/^You canceled the transfer of .+$/ => 'file-transfer-cancel',
+		/^Transfer of file .+ complete$/ => 'fileTransferCompleted',
+		# sending errors
+		/^Last outgoing message not received properly- resetting$/ => 'sending-error',
+		/^Resending\.\.\.$/ => 'sending-error',
+		# connection errors
+		/^Lost connection with the remote user:<br\/>Remote host closed connection\.$/ => 'lost-remote-conn',
+		# direct IM stuff
+		/^Attempting to connect to .+ at .+ for Direct IM\./ => 'direct-im-connect',
+		/^Asking .+ to connect to us at .+ for Direct IM\./ => 'direct-im-ask',
+		/^Direct IM with .+ failed/ => 'direct-im-failed',
+		/^Attempting to connect to .+\.$/ => 'direct-im-connect',
+		/^Attempting to connect via proxy server\.$/ => 'direct-im-proxy',
+		/^Direct IM established$/ => 'direct-im-established',
+		/^Lost connection with the remote user:<br\/>Windows socket error/ => 'direct-im-lost-conn',
+		# chats
+		/^.+ entered the room\.$/ => 'chat-entered-room',
+		/^.+ left the room\.$/ => 'chat-left-room'
+	    }
+
+	    regex, status = status_map.detect{ |regex, status| regex.match(str) }
+	    if regex and status
+		alias_and_status = [regex.match(str)[1], status]
+	    else
+		# not one of the regular statuses, try my statuses.
+		regex, status = my_status_map.detect{ |regex, status| regex.match(str) }
+		alias_and_status = ['System Message', status]
+	    end
+	    return alias_and_status
+	end
+
+	def getTimeZoneOffset()
+	    tz_regex = /([-+]\d+)[A-Z]{3}\.(txt|html?)/
+	    tz_match = tz_regex.match(@srcPath)
+	    tz_offset =  tz_match.nil? ? @userTZOffset : tz_match[1]
+	    return tz_offset
+	end
+
+	# parseFile slurps up @srcPath into one big string and runs
+	# SrcHtmlFileParse.cleanup if it's an HTML file.
+	# It then uses regexes to break up the string, uses createMsgData
+	# to turn the regex MatchData into data hashes, and feeds it to
+	# ChatFileGenerator, which creates the XML data string.
+	# This method returns a ChatFileGenerator object.
+	def parseFile()
+	    fileContent = File.read(@srcPath) # one big string
+	    if self.class == SrcHtmlFileParse
+		fileContent = self.cleanup(fileContent)
+	    end
+	    # Deal with first line.
+	    first_line_match = @first_line_regex.match(fileContent)
+
+	    if first_line_match.nil?
+		Pidgin2Adium.logMsg("Parsing of #{@srcPath} failed (could not find first line).", true)
+		return false
+	    end
+	    service = first_line_match[4]
+	    # mySN is standardized to avoid "AIM.name" and "AIM.na me" folders
+	    mySN = first_line_match[3].downcase.sub(' ', '')
+	    otherPersonsSN = first_line_match[1]
+	    chatTimePidgin_start = first_line_match[2]
+	    chatFG = ChatFileGenerator.new(service,
+					   mySN,
+					   otherPersonsSN,
+					   chatTimePidgin_start,
+					   getTimeZoneOffset(),
+					   @masterAlias,
+					   @destDirBase)
+	    all_line_matches = fileContent.scan( Regexp.union(@line_regex, @line_regex_status) )
+
+	    # an empty chat window that got saved
+	    if all_line_matches.empty?
+		return chatFG
+	    end
+
+	    all_line_matches.each do |line|
+		chatFG.appendLine( createMsgData(line) )
+	    end
+	    return chatFG
+	end
+    end
+
+    class SrcTxtFileParse < SrcFileParse
+	def initialize(srcPath, destDirBase, masterAlias, userTZ, userTZOffset)
+	    super(srcPath, destDirBase, masterAlias, userTZ, userTZOffset)
+	    # @line_regex matches a line in an HTML log file other than the first
+	    # @line_regex matchdata:
+	    # 0: timestamp
+	    # 1: screen name
+	    # 2: "<AUTO-REPLY>" or nil
+	    # 3: message
+	    @line_regex = /#{@timestamp_regex_str} (.*?) ?(<AUTO-REPLY>)?: (.*)$/
+	    # @line_regex_status matches a status line
+	    # @line_regex_status matchdata:
+	    # 0: timestamp
+	    # 1: message
+	    @line_regex_status = /#{@timestamp_regex_str} ([^:]+?)[\r\n]{1,2}/
+	end
+
+	# createMsgData takes a +MatchData+ object (from @line_regex or @line_regex_status) and returns a hash
+	# with the following keys: time, alias, and message and/or status.
+	def createMsgData(matchObj)
+	    msg_data_hash = { 'time' => nil, 'alias' => nil, 'status' => nil, 'body' => nil, 'auto-reply' => nil }
+	    if matchObj[4..5] == [nil, nil]
+		# regular message
+		# ["10:58:29", "BuddyName", "<AUTO-REPLY>", "hello!\r", nil, nil]
+		msg_data_hash['time'] = matchObj[0]
+		msg_data_hash['alias'] = matchObj[1]
+		msg_data_hash['auto-reply'] = (matchObj[2] != nil)
+		# strip() to remove "\r" from end
+		msg_data_hash['body'] = matchObj[3].strip
+	    elsif matchObj[0..3] == [nil, nil, nil, nil]
+		# status message
+		# [nil, nil, nil, nil, "22:58:00", "BuddyName logged in."]
+		alias_and_status = getAliasAndStatus(matchObj[5])
+		msg_data_hash['time'] = matchObj[4]
+		msg_data_hash['alias'] = alias_and_status[0]
+		msg_data_hash['status'] = alias_and_status[1]
+	    end
+	    return msg_data_hash
+	end
+    end
+
+    class SrcHtmlFileParse < SrcFileParse
+	def initialize(srcPath, destDirBase, masterAlias, userTZ, userTZOffset)
+	    super(srcPath, destDirBase, masterAlias, userTZ, userTZOffset)
+	    # @line_regex matches a line in an HTML log file other than the first
+	    # time matches on either "2008-11-17 14:12" or "14:12"
+	    # @line_regex match obj:
+	    # 0: timestamp, extended or not
+	    # 1: alias
+	    # 2: "&lt;AUTO-REPLY&gt;" or nil
+	    # 3: message body
+	    #  <span style='color: #000000;'>test sms</span>
+	    @line_regex = /#{@timestamp_regex_str} ?<b>(.*?) ?(&lt;AUTO-REPLY&gt;)?:?<\/b> ?(.*)<br ?\/>/ #(?:[\n\r]{1,2}<(?:font|\/body))/s
+	    # @line_regex_status matches a status line
+	    # @line_regex_status match obj:
+	    # 0: timestamp
+	    # 1: status message
+	    @line_regex_status = /#{@timestamp_regex_str} ?<b> (.*?)<\/b><br\/>/
+	end
+
+	# createMsgData takes a +MatchData+ object (from @line_regex or @line_regex_status) and returns a hash
+	# with the following keys: time, alias, and message and/or status.
+	def createMsgData(matchObj)
+	    msg_data_hash = { 'time' => nil,
+		'alias' => nil,
+		'auto-reply' => nil,
+		'body' => nil,
+		'status' => nil}
+	    # the Regexp.union leaves nil where one of the regexes didn't match.
+	    # (Is there any way to have it not do this?)
+	    # ie
+	    # the first one matches: ['foo', 'bar', 'baz', 'bash', nil, nil]
+	    # second one matches: [nil, nil, nil, nil, 'bim', 'bam']
+	    if matchObj[0..3] == [nil, nil, nil, nil]
+		# This is a status message.
+		# slice off results from other Regexp
+		# becomes: ["11:27:53", "Generic Screenname228 logged in."]
+		matchObj = matchObj[4..5]
+		alias_and_status = getAliasAndStatus(matchObj[1])
+		msg_data_hash['time'] = matchObj[0]
+		msg_data_hash['alias'] = alias_and_status[0]
+		msg_data_hash['status'] = alias_and_status[1]
+	    elsif matchObj[4..5] == [nil, nil]
+		# Either a regular message line or an auto-reply/away message.
+		# slice off results from other Regexp
+		matchObj = matchObj[0..3]
+		msg_data_hash['time'] = matchObj[0]
+		msg_data_hash['alias'] = matchObj[1]
+		msg_data_hash['body'] = matchObj[3]
+		if not matchObj[2].nil?
+		    # an auto-reply message
+		    msg_data_hash['auto-reply'] = true
+		end
+	    end
+	    return msg_data_hash
+	end
+
+	# Removes <font> tags, empty <a>s, spans with either no color
+	# information or color information that just turns the text black.
+	# Returns a string.
+	def cleanup(text)
+	    color_regex = /.*(color: ?#[[:alnum:]]{6}; ?).*/
+	    # For some reason, Hpricot doesn't work well with
+	    # elem.swap(elem.innerHTML) when the elements are nested
+	    # (eg doc.search('font') only returns the outside <font> tags,
+	    # not "font font") and also it appears that it doesn't reinterpret
+	    # the doc when outside tags are swapped with their innerHTML (so
+	    # when <html> tags are replaced with their innerHTML, then
+	    # a search for <font> tags in the new HTML fails).
+	    # Long story short, we use gsub.
+	    text.gsub!(/<\/?(html|body|font).*?>/, '')
+	    doc = Hpricot(text)
+	    # These empty links sometimes are appended to every line in a chat,
+	    # for some weird reason. Remove them.
+	    doc.search("a[text()='']").remove
+	    spans = doc.search('span')
+	    spans.each do |span|
+		if span.empty?
+		    Hpricot::Elements[span].remove
+		else
+		    # No need to check for the span.attributes.key?('style')
+		    if span[:style] =~ color_regex
+			# Remove black-text spans after other processing because
+			# the processing can reduce spans to that
+			span[:style] = span[:style].gsub(color_regex, '\1').
+					    gsub(/color: ?#000000; ?/,'')
+			# Remove span but keep its contents
+			span.swap(span.innerHTML) if span[:style] == ''
+		    else
+			span.swap(span.innerHTML)
+		    end
+		end
+	    end
+	    return doc.to_html
+	end
+    end
+end # end module

data/lib/pidgin2adium/balance-tags.rb

@@ -0,0 +1,115 @@
+
+module Pidgin2Adium
+    #From Wordpress's formatting.php; rewritten in Ruby by Gabe Berke-Williams, 2009.
+    #Balances tags of string using a modified stack.
+    #
+    # @author Leonard Lin <leonard@acm.org>
+    # @license GPL v2.0
+    # @copyright November 4, 2001
+    # @return string Balanced text.
+    def Pidgin2Adium.balance_tags( text )
+	tagstack = []
+	stacksize = 0
+	tagqueue = ''
+	newtext = ''
+	single_tags = ['br', 'hr', 'img', 'input', 'meta'] # Known single-entity/self-closing tags
+	nestable_tags = ['blockquote', 'div', 'span'] # Tags that can be immediately nested within themselves
+	tag_regex = /<(\/?\w*)\s*([^>]*)>/
+
+	    # WP bug fix for comments - in case you REALLY meant to type '< !--'
+	    text.gsub!('< !--', '<    !--')
+	# WP bug fix for LOVE <3 (and other situations with '<' before a number)
+	text.gsub!(/<([0-9]{1})/, '&lt;\1')
+
+	while ( regex = text.match(tag_regex) )
+	    regex = regex.to_a
+	    newtext += tagqueue
+	    i = text.index(regex[0])
+	    l = regex[0].length
+
+	    # clear the shifter
+	    tagqueue = ''
+	    # Pop or Push
+	    if (regex[1][0,1] == "/") # End Tag
+		tag = regex[1][1,regex[1].length].downcase
+		# if too many closing tags
+		if(stacksize <= 0)
+		    tag = ''
+		    #or close to be safe tag = '/' . tag
+		    # if stacktop value = tag close value then pop
+		elsif (tagstack[stacksize - 1] == tag) # found closing tag
+		    tag = '</' + tag + '>'; # Close Tag
+		    # Pop
+		    tagstack.pop
+		    stacksize -= 1
+		else # closing tag not at top, search for it
+		    (stacksize-1).downto(0) do |j|
+			if (tagstack[j] == tag)
+			    # add tag to tagqueue
+			    ss = stacksize - 1
+			    ss.downto(j) do |k|
+				tagqueue += '</' + tagstack.pop + '>'
+				stacksize -= 1
+			    end
+			    break
+			end
+		    end
+		    tag = ''
+		end
+	    else
+		# Begin Tag
+		tag = regex[1].downcase
+
+		# Tag Cleaning
+		if( (regex[2].slice(-1,1) == '/') || (tag == '') )
+		    # If: self-closing or '', don't do anything.
+		elsif ( single_tags.include?(tag) )
+		    # ElseIf: it's a known single-entity tag but it doesn't close itself, do so
+		    regex[2] += '/'
+		else
+		    # Push the tag onto the stack
+		    # If the top of the stack is the same as the tag we want to push, close previous tag
+		    if ((stacksize > 0) &&
+			! nestable_tags.include?(tag) &&
+			(tagstack[stacksize - 1] == tag))
+			tagqueue = '</' + tagstack.pop + '>'
+			stacksize -= 1
+		    end
+		    stacksize = tagstack.push(tag).length
+		end
+
+		# Attributes
+		attributes = regex[2]
+		if(attributes != '')
+		    attributes = ' ' + attributes
+		end
+		tag = '<' + tag + attributes + '>'
+		#If already queuing a close tag, then put this tag on, too
+		if (tagqueue)
+		    tagqueue += tag
+		    tag = ''
+		end
+	    end
+	    newtext += text[0,i] + tag
+	    # text = substr(text,i+l)
+	    text = text[i+l, text.length - (i+l)]
+	end
+
+	# Clear Tag Queue
+	newtext += tagqueue
+
+	# Add Remaining text
+	newtext += text
+
+	# Empty Stack
+	while(x = tagstack.pop)
+	    newtext += '</' + x + '>'; # Add remaining tags to close
+	end
+
+	# WP fix for the bug with HTML comments
+	newtext.gsub!("< !--", "<!--")
+	newtext.gsub!("<    !--", "< !--")
+
+	return newtext
+    end
+end

data/lib/pidgin2adium/logs.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/ruby -w
+
+#Author: Gabe Berke-Williams, 2008
+#With thanks to Li Ma, whose blog post at
+#http://li-ma.blogspot.com/2008/10/pidgin-log-file-to-adium-log-converter.html
+#helped tremendously.
+#
+#A ruby program to convert Pidgin log files to Adium log files, then place
+#them in the Adium log directory with allowances for time zone differences.
+
+class Time
+    ZoneOffset = {
+	'UTC' => 0,
+	# ISO 8601
+	'Z' => 0,
+	# RFC 822
+	'UT' => 0, 'GMT' => 0,
+	'EST' => -5, 'EDT' => -4,
+	'CST' => -6, 'CDT' => -5,
+	'MST' => -7, 'MDT' => -6,
+	'PST' => -8, 'PDT' => -7,
+	# Following definition of military zones is original one.
+	# See RFC 1123 and RFC 2822 for the error in RFC 822.
+	'A' => +1, 'B' => +2, 'C' => +3, 'D' => +4,  'E' => +5,  'F' => +6, 
+	'G' => +7, 'H' => +8, 'I' => +9, 'K' => +10, 'L' => +11, 'M' => +12,
+	'N' => -1, 'O' => -2, 'P' => -3, 'Q' => -4,  'R' => -5,  'S' => -6, 
+	'T' => -7, 'U' => -8, 'V' => -9, 'W' => -10, 'X' => -11, 'Y' => -12
+    }
+    # Returns offset in hours, e.g. '+0900'
+    def Time.zone_offset(zone, year=Time.now.year)
+	off = nil
+	zone = zone.upcase
+	if /\A([+-])(\d\d):?(\d\d)\z/ =~ zone
+	    off = ($1 == '-' ? -1 : 1) * ($2.to_i * 60 + $3.to_i) * 60
+	elsif /\A[+-]\d\d\z/ =~ zone
+	    off = zone.to_i
+	elsif ZoneOffset.include?(zone)
+	    off = ZoneOffset[zone]
+	elsif ((t = Time.local(year, 1, 1)).zone.upcase == zone rescue false)
+	    off = t.utc_offset / 3600
+	elsif ((t = Time.local(year, 7, 1)).zone.upcase == zone rescue false)
+	    off = t.utc_offset / 3600
+	end
+	off
+    end
+end
+
+module Pidgin2Adium
+    require 'pidgin2adium/SrcFileParse'
+    require 'pidgin2adium/ChatFileGenerator'
+    require 'parsedate'
+    require 'fileutils'
+    
+    # put's content. Also put's to @LOG_FILE_FH if @debug == true.
+    def Pidgin2Adium.logMsg(str, isError=false)
+	content = str.to_s
+	if isError == true
+	    content= "ERROR: #{str}"
+	end
+	puts content
+    end
+
+    class Logs
+	# FILE_EXISTS is returned by ChatFileGenerator.buildDomAndOutput() if the output logfile already exists.
+	FILE_EXISTS = 42
+	def initialize(src, out, aliases, libdir, tz=nil, debug=false)
+	    # These files/directories show up in Dir.entries(x)
+	    @BAD_DIRS = %w{. .. .DS_Store Thumbs.db .system}
+	    src = File.expand_path(src)
+	    out = File.expand_path(out)
+	    unless File.directory?(src)
+		puts "Source directory #{src} does not exist or is not a directory."
+		raise Errno::ENOENT
+	    end
+	    unless File.directory?(out)
+		begin
+		    FileUtils.mkdir_p(out)
+		rescue
+		    puts "Output directory #{out} does not exist or is not a directory and could not be created."
+		    raise Errno::ENOENT
+		end
+	    end
+
+	    if libdir.nil?
+		puts "You must provide libdir."
+		raise Error
+	    end
+
+	    @src_dir = src
+	    @out_dir = out
+
+	    # Whitespace is removed for easy matching later on.
+	    @my_aliases = aliases.map{|x| x.downcase.gsub(/\s+/,'') }.uniq
+	    # @libdir is the directory in
+	    # ~/Library/Application Support/Adium 2.0/Users/Default/Logs/.
+	    # For AIM, it's like "AIM.<screenname>"
+	    @libdir = libdir
+	    @debug = debug
+	    @DEFAULT_TIME_ZONE = tz || Time.now.zone
+	    # local offset, like "-0800" or "+1000"
+	    @DEFAULT_TZ_OFFSET = '%+03d00'%Time.zone_offset(@DEFAULT_TIME_ZONE)
+	end
+
+	def start
+	    Pidgin2Adium.logMsg "Begin converting."
+	    begin
+		filesPath = getAllChatFilesPath(@src_dir)
+	    rescue Errno::EACCES => bang
+		Pidgin2Adium.logMsg("Sorry, permission denied for getting chat files from #{@src_dir}.", true)
+		Pidgin2Adium.logMsg("Details: #{bang.message}", true)
+		raise Errno::EACCES
+	    end
+
+	    Pidgin2Adium.logMsg(filesPath.length.to_s + " files to convert.")
+	    filesPath.each do |fname|
+		Pidgin2Adium.logMsg("Converting #{fname}...")
+		convert(fname)
+	    end
+
+	    copyLogs()
+	    deleteSearchIndexes()
+
+	    Pidgin2Adium.logMsg "Finished converting! Converted #{filesPath.length} files."
+	end
+
+
+	# Problem: imported logs are viewable in the Chat Transcript Viewer, but are not indexed,
+	# so a search of the logs doesn't give results from the imported logs.
+	# To fix this, we delete the cached log indexes, which forces Adium to re-index.
+	def deleteSearchIndexes()
+	    Pidgin2Adium.logMsg "Deleting log search indexes in order to force re-indexing of imported logs..."
+	    dirtyFile=File.expand_path("~/Library/Caches/Adium/Default/DirtyLogs.plist")
+	    logIndexFile=File.expand_path("~/Library/Caches/Adium/Default/Logs.index")
+	    [dirtyFile, logIndexFile].each do |f|
+		if File.exist?(f)
+		    if File.writable?(f)
+			File.delete(f)
+		    else
+			Pidgin2Adium.logMsg("#{f} exists but is not writable. Please delete it yourself.", true)
+		    end
+		end
+	    end
+	    Pidgin2Adium.logMsg "...done."
+	    Pidgin2Adium.logMsg "When you next start the Adium Chat Transcript Viewer, it will re-index the logs, which may take a while."
+	end
+
+	# <tt>convert</tt> creates a new SrcHtmlFileParse or SrcTxtFileParse object,
+	# as appropriate, and calls its parse() method.
+	# Returns false if there was a problem, true otherwise
+	def convert(srcPath)
+	    ext = File.extname(srcPath).sub('.', '').downcase
+	    if(ext == "html" || ext == "htm")
+		srcFileParse = SrcHtmlFileParse.new(srcPath, @out_dir, @my_aliases, @DEFAULT_TIME_ZONE, @DEFAULT_TZ_OFFSET)
+	    elsif(ext == "txt")
+		srcFileParse = SrcTxtFileParse.new(srcPath, @out_dir, @my_aliases, @DEFAULT_TIME_ZONE, @DEFAULT_TZ_OFFSET)
+	    elsif(ext == "chatlog")
+		# chatlog FILE, not directory
+		Pidgin2Adium.logMsg("Found chatlog FILE - moving to chatlog DIRECTORY.")
+		# Create out_dir/log.chatlog/
+		begin
+		    toCreate = "#{@out_dir}/#{srcPath}" 
+		    Dir.mkdir(toCreate)
+		rescue => bang
+		    Pidgin2Adium.logMsg("Could not create #{toCreate}: #{bang.class} #{bang.message}", true)
+		    return false
+		end
+		fileWithXmlExt = srcPath[0, srcPath.size-File.extname(srcPath).size] + ".xml"
+		# @src_dir/log.chatlog (file) -> @out_dir/log.chatlog/log.xml
+		File.cp(srcPath, File.join(@out_dir, srcPath, fileWithXmlExt))
+		Pidgin2Adium.logMsg("Copied #{srcPath} to " + File.join(@out_dir, srcPath, fileWithXmlExt))
+		return true
+	    else
+		Pidgin2Adium.logMsg("srcPath (#{srcPath}) is not a txt, html, or chatlog file. Doing nothing.")
+		return false
+	    end
+
+	    chatFG = srcFileParse.parseFile()
+	    return false if chatFG == false
+
+	    destFilePath = chatFG.convert()
+	    return \
+		case destFilePath
+		when false
+		    Pidgin2Adium.logMsg("Converting #{srcPath} failed.", true); 
+		    false
+		when FILE_EXISTS
+		    Pidgin2Adium.logMsg("File already exists.")
+		    true
+		else
+		    Pidgin2Adium.logMsg("Output to: #{destFilePath}")
+		    true
+		end
+	end
+
+	def getAllChatFilesPath(dir)
+	    return [] if File.basename(dir) == ".system"
+	    # recurse into each subdir
+	    return (Dir.glob(File.join(@src_dir, '**', '*.{html,txt}')) - @BAD_DIRS)
+	end
+
+	# Copies logs, accounting for timezone changes
+	def copyLogs
+	    Pidgin2Adium.logMsg "Copying logs with accounting for different time zones..."
+	    real_dest_dir = File.expand_path('~/Library/Application Support/Adium 2.0/Users/Default/Logs/') + '/' + @libdir + '/'
+	    real_src_dir = File.join(@out_dir, @libdir) + '/'
+
+	    src_entries =  Dir.entries(real_src_dir)
+	    dest_entries =  Dir.entries(real_dest_dir)
+	    both_entries = (src_entries & dest_entries) - @BAD_DIRS
+
+	    both_entries.each do |name|
+		my_src_entries = Dir.entries(real_src_dir + name) - @BAD_DIRS
+		my_dest_entries = Dir.entries(real_dest_dir + name) - @BAD_DIRS
+
+		in_both = my_src_entries & my_dest_entries
+		in_both.each do |logdir|
+		    FileUtils.cp(
+			File.join(real_src_dir, name, logdir, logdir.sub('chatlog', 'xml')),
+				 File.join(real_dest_dir, name, logdir) + '/',
+				 :verbose => false)
+		end
+		# The logs that are only in one of the dirs are not necessarily different logs than the dest.
+		# They might just have different timestamps. Thus, we use regexes.
+		only_in_src  = my_src_entries - in_both
+		only_in_dest = my_dest_entries - in_both
+		# Move files from real_src_dir that are actually in both, but just have different time zones.
+		only_in_src.each do |srcLogDir|
+		    # Match on everything except the timezone ("-0400.chatlog")
+		    fname_beginning_regex = Regexp.new( Regexp.escape(srcLogDir.sub(/-\d{4}.\.chatlog$/, '')) )
+		    target_chatlog_dir = only_in_dest.find{|d| d =~ fname_beginning_regex }
+		    if target_chatlog_dir.nil?
+			# Only in source, so we can copy it without fear of overwriting.
+			target_chatlog_dir = srcLogDir
+			FileUtils.mkdir_p(File.join(real_dest_dir, name, target_chatlog_dir))
+		    end
+		    # Move to target_chatlog_dir so we overwrite the destination
+		    # file but still use its timestamp
+		    # (if it exists; if it doesn't, then we're using our own
+		    # timestamp).
+		    FileUtils.cp(
+			File.join(real_src_dir, name, srcLogDir, srcLogDir.sub('chatlog', 'xml')),
+			File.join(real_dest_dir, name, target_chatlog_dir, target_chatlog_dir.sub('chatlog', 'xml')),
+			:verbose => false
+		    )
+		end
+	    end
+	    Pidgin2Adium.logMsg "Log files copied!"
+	end
+    end
+end

data/lib/pidgin2adium/status.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/ruby
+
+# Author: Gabe Berke-Williams 2008-11-25
+# Requires rubygems and hpricot (http://wiki.github.com/why/hpricot)
+
+# Script to import pidgin logs into Adium. It uses Applescript to create new statuses in Adium.
+# Stupid binary status file format. Thanks a lot, Adium.
+# It doesn't work in Mac OSX 10.5 (Leopard).
+# See: http://trac.adiumx.com/ticket/8863
+# It should work in Mac OSX 10.4 (Tiger), but is untested.
+
+# location of status.xml
+
+require 'rubygems'
+require 'hpricot'
+
+module Pidgin2Adium
+    class Status
+	def initialize(xml_file)
+	    @xml_file = File.expand_path(xml_file)
+	    #xml_file=File.expand_path("~/Desktop/purple/status.xml")
+	    # Unescape for Adium.
+	    @TRANSLATIONS = {
+		'&' => '&',
+		'&lt;' => '<',
+		'&gt;' => '>',
+		# escape quotes for shell quoting in tell -e 'blah' below
+		'&quot;' => '\"',
+		'&apos;' => "\\'",
+		"<br>" => "\n"
+	    }
+	end
+	
+	def start
+	    # For some reason Hpricot doesn't like entities in attributes,
+	    # but since that only affects the status name, which only we see,
+	    # that's not really a problem.
+	    doc = Hpricot( File.read(xml_file) )
+	    $max_id = get_max_status_id
+	    # remove <substatus>'s because sometimes their message is different
+	    # from the actual message, and we don't want to grab them accidentally
+	    doc.search('substatus').remove
+
+	    doc.search('status').each do |status|
+		next if status.search('message').empty?
+		add_status_to_adium(status)
+	    end
+
+	    puts "All statuses have been migrated. Enjoy!"
+	end
+
+
+	def unescape(str)
+	    unescaped_str = str.clone
+	    # Unescape the escaped entities in Pidgin's XML.
+	    # translate "&amp;" first because sometimes the entities are
+	    # like "&amp;gt;"
+	    unescaped_str.gsub!('&amp;', '&')
+	    TRANSLATIONS.each do |k,v|
+		unescaped_str.gsub!(k, v)
+	    end
+	    return unescaped_str
+	end
+
+	def get_max_status_id
+	    # osascript line returns like so: "-1000, -8000, -1001, 24, -1002\n"
+	    # Turn the single String into an array of Fixnums.
+	    script = `osascript -e 'tell application "Adium" to get id of every status'`
+	    id = script.split(',').map{ |x| x.to_i }.max
+	    return id
+	end
+
+	def add_status_to_adium(elem)
+	    # pass in <status> element
+	    id = ($max_id += 1)
+	    # status_type is invisible/available/away
+	    status_type = elem.search('state').inner_html
+	    title = unescape( elem[:name] )
+	    status_message = unescape( elem.search(:message).inner_html )
+	    puts '-' * 80
+	    puts "status_type: #{status_type}"
+	    puts "title: #{title}"
+	    puts "status_message: #{status_message}"
+	    puts '-' * 80
+	    # TODO: when it actually works, remove this line
+	    command="osascript -e 'tell application \"Adium\" to set myStat to (make new status with properties {id:#{id}, saved:true, status type:#{status_type}, title:\"#{title}\", message:\"#{status_message}\", autoreply:\"#{status_message}\"})'"
+	    # TODO: popen[123]?
+	    p `#{command}`
+	    if $? != 0
+		puts "*" * 80
+		puts "command: #{command}"
+		puts "Uh-oh. Something went wrong."
+		puts "The command that failed is above."
+		# given 10.x.y, to_f leaves off y
+		if `sw_vers -productVersion`.to_f == 10.5
+		    puts "You are running Mac OS X 10.5 (Leopard)."
+		    puts "This script does not work for that version."
+		    puts "It should work for Mac OS X 10.4 (Tiger),"
+		    puts "but is untested."
+		    puts "See: http://trac.adiumx.com/ticket/8863"
+		end
+		puts "Return status: #{$?}"
+		puts "Error, exiting."
+		raise "You need Mac OS X Tiger (10.4)"
+	    end
+	end
+    end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: pidgin2adium
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gabe B-W
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-05 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.1
+    version: 
+description: Converts Pidgin logs and statuses to Adium format and makes them available to Adium. Also installstwo shell scripts, pidgin2adium_logs and pidgin2adium_status.
+email: gbw@rubyforge.org
+executables: 
+- pidgin2adium_logs
+- pidgin2adium_status
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pidgin2adium/balance-tags.rb
+- lib/pidgin2adium/ChatFileGenerator.rb
+- lib/pidgin2adium/logs.rb
+- lib/pidgin2adium/SrcFileParse.rb
+- lib/pidgin2adium/status.rb
+has_rdoc: true
+homepage: http://pidgin2adium.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pidgin2adium
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Converts Pidgin logs and statuses to Adium format and makes them available to Adium.
+test_files: []
+