pidgin2adium 3.0.1 → 3.1.0

data/lib/pidgin2adium/message.rb

@@ -0,0 +1,97 @@
+# The Message class and its subclasses, each used for holding one line of a
+# chat.
+
+module Pidgin2Adium
+  # A holding object for each line of the chat. It is subclassed as
+  # appropriate (eg AutoReplyMessage). Each subclass (but not Message
+  # itself) has its own to_s which prints out its information in a format
+  # appropriate for putting in an Adium log file.
+  # Subclasses: XMLMessage, AutoReplyMessage, StatusMessage, Event.
+  class Message
+    def initialize(sender, time, buddy_alias)
+      # The sender's screen name
+      @sender = sender
+      # The time the message was sent, in Adium format (e.g.
+      # "2008-10-05T22:26:20-0800")
+      @time = time
+      # The receiver's alias (NOT screen name)
+      @buddy_alias = buddy_alias
+    end
+    attr_accessor :sender, :time, :buddy_alias
+  end
+
+  # Basic message with body text (as opposed to pure status messages, which
+  # have no body).
+  class XMLMessage < Message
+    def initialize(sender, time, buddy_alias, body)
+      super(sender, time, buddy_alias)
+      @body = body
+      @styled_body = '<div><span style="font-family: Helvetica; font-size: 12pt;">%s</span></div>' % @body
+      normalize_body!()
+    end
+    attr_accessor :body
+
+    def to_s
+      return sprintf('<message sender="%s" time="%s" alias="%s">%s</message>' << "\n",
+                     @sender, @time, @buddy_alias, @styled_body)
+    end
+
+    # Balances mismatched tags, normalizes body style, and fixes actions
+    # so they are in Adium style (Pidgin uses "***Buddy waves at you", Adium uses
+    # "*Buddy waves at you*").
+    def normalize_body!
+      normalize_body_entities!()
+      # Fix mismatched tags. Yes, it's faster to do it per-message
+      # than all at once.
+      @body = Pidgin2Adium.balance_tags_c(@body)
+      if @buddy_alias[0,3] == '***'
+        # "***<alias>" is what pidgin sets as the alias for a /me action
+        @buddy_alias.slice!(0,3)
+        @body = '*' << @body << '*'
+      end
+    end
+
+    # Escapes entities.
+    def normalize_body_entities!
+      # Convert '&' to '&amp;' only if it's not followed by an entity.
+      @body.gsub!(/&(?!lt|gt|amp|quot|apos)/, '&amp;')
+    end
+  end # END XMLMessage class
+
+  # An auto reply message.
+  class AutoReplyMessage < XMLMessage
+    def to_s
+      return sprintf('<message sender="%s" time="%s" auto="true" alias="%s">%s</message>' << "\n",
+                     @sender, @time, @buddy_alias, @styled_body)
+    end
+  end # END AutoReplyMessage class
+
+  # A message saying e.g. "Blahblah has gone away."
+  class StatusMessage < Message
+    def initialize(sender, time, buddy_alias, status)
+      super(sender, time, buddy_alias)
+      @status = status
+    end
+    attr_accessor :status
+
+    def to_s
+      return sprintf('<status type="%s" sender="%s" time="%s" alias="%s"/>' << "\n", @status, @sender, @time, @buddy_alias)
+    end
+  end # END StatusMessage class
+
+  # Pidgin does not have Events, but Adium does. Pidgin mostly uses system
+  # messages to display what Adium calls events. These include sending a file,
+  # starting a Direct IM connection, or an error in chat.
+  class Event < XMLMessage
+    def initialize(sender, time, buddy_alias, body, event_type)
+      super(sender, time, buddy_alias, body)
+      @event_type = event_type
+    end
+    attr_accessor :event_type
+
+    def to_s
+      return sprintf('<event type="%s" sender="%s" time="%s" alias="%s">%s</event>',
+                     @event_type, @sender, @time, @buddy_alias, @styled_body)
+    end
+  end # END Event class
+end

data/lib/pidgin2adium/text_log_parser.rb

@@ -0,0 +1,39 @@
+# TextLogParser class, a subclass of BasicParser.
+# Used for parse()ing text logs.
+
+module Pidgin2Adium
+  class TextLogParser < BasicParser
+    def initialize(src_path, user_aliases)
+      super(src_path, user_aliases)
+      @timestamp_rx = '\((\d{1,2}:\d{1,2}:\d{1,2})\)'
+
+      # @line_regex matches a line in a TXT log file other than the first
+      # @line_regex matchdata:
+      # 0: timestamp
+      # 1: screen name or alias, if alias set
+      # 2: "<AUTO-REPLY>" or nil
+      # 3: message body
+      @line_regex = /#{@timestamp_rx} (.*?) ?(<AUTO-REPLY>)?: (.*)/o
+      # @line_regex_status matches a status line
+      # @line_regex_status matchdata:
+      # 0: timestamp
+      # 1: status message
+      @line_regex_status = /#{@timestamp_rx} ([^:]+)/o
+    end
+
+    def cleanup(text)
+      text.tr!("\r", '')
+      # Escape entities since this will be in XML
+      text.gsub!('&', '&amp;') # escape '&' first
+      text.gsub!('<', '&lt;')
+      text.gsub!('>', '&gt;')
+      text.gsub!('"', '&quot;')
+      text.gsub!("'", '&apos;')
+      # Replace newlines with "<br/>" unless they end a chat line.
+      # Add the <br/> after converting to &lt; etc so we
+      # don't escape the tag.
+      text.gsub!(/\n(?!(#{@timestamp_rx}|\Z))/, '<br/>')
+      return text
+    end
+  end # END TextLogParser class
+end

data/pidgin2adium.gemspec

@@ -5,45 +5,61 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pidgin2adium}
-  s.version = "3.0.1"
+  s.version = "3.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gabe Berke-Williams"]
-  s.date = %q{2010-08-07}
+  s.date = %q{2010-08-13}
+  s.default_executable = %q{pidgin2adium}
   s.description = %q{Pidgin2Adium is a fast, easy way to convert Pidgin (formerly gaim) logs to the Adium format.}
   s.email = %q{gbw@brandeis.edu}
-  s.executables = ["pidgin2adium", "pidgin2adium_profiler"]
+  s.executables = ["pidgin2adium"]
   s.extensions = ["ext/balance_tags_c/extconf.rb"]
   s.extra_rdoc_files = [
-    "LICENSE",
+    "ChangeLog",
+     "LICENSE",
      "README.rdoc"
   ]
   s.files = [
     ".autotest",
      ".gitignore",
      ".rspec",
+     "ChangeLog",
      "Gemfile",
-     "History.txt",
      "LICENSE",
      "Manifest.txt",
      "README.rdoc",
      "Rakefile",
      "VERSION",
      "bin/pidgin2adium",
-     "bin/pidgin2adium_profiler",
      "config/website.yml",
      "ext/balance_tags_c/balance_tags_c.c",
      "ext/balance_tags_c/extconf.rb",
      "lib/pidgin2adium.rb",
      "lib/pidgin2adium/balance_tags.rb",
+     "lib/pidgin2adium/basic_parser.rb",
+     "lib/pidgin2adium/html_log_parser.rb",
      "lib/pidgin2adium/log_converter.rb",
      "lib/pidgin2adium/log_file.rb",
      "lib/pidgin2adium/log_parser.rb",
+     "lib/pidgin2adium/message.rb",
+     "lib/pidgin2adium/text_log_parser.rb",
      "pidgin2adium.gemspec",
+     "spec/balance_tags_c_extn_spec.rb",
+     "spec/basic_parser_spec.rb",
+     "spec/html_log_parser_spec.rb",
+     "spec/log_converter_spec.rb",
+     "spec/log_file_spec.rb",
+     "spec/logfiles/2006-12-21.223606.txt",
+     "spec/logfiles/2008-01-15.071445-0500PST.htm",
+     "spec/logfiles/2008-01-15.071445-0500PST.html",
      "spec/pidgin2adium_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
-     "tasks/build_profiler.rake",
+     "spec/test-output/README.md",
+     "spec/test-output/html_log_output.xml",
+     "spec/test-output/text_log_output.xml",
+     "spec/text_log_parser_spec.rb",
      "tasks/extconf.rake",
      "tasks/extconf/balance_tags_c.rake"
   ]
@@ -53,8 +69,14 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Pidgin2Adium is a fast, easy way to convert Pidgin (formerly gaim) logs to the Adium format}
   s.test_files = [
-    "spec/pidgin2adium_spec.rb",
-     "spec/spec_helper.rb"
+    "spec/balance_tags_c_extn_spec.rb",
+     "spec/basic_parser_spec.rb",
+     "spec/html_log_parser_spec.rb",
+     "spec/log_converter_spec.rb",
+     "spec/log_file_spec.rb",
+     "spec/pidgin2adium_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/text_log_parser_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/balance_tags_c_extn_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext', 'balance_tags_c'))
+require "balance_tags_c"
+
+describe "BalanceTagsCExtension" do
+  describe "text without tags" do
+    it "should be left untouched" do
+      text = "Foo bar baz, this is my excellent test text!"
+      Pidgin2Adium.balance_tags_c(text).should == text
+    end
+  end
+
+  describe "text with tags" do
+    it "should be balanced correctly" do
+      Pidgin2Adium.balance_tags_c('<p><b>this is unbalanced!').should == "<p><b>this is unbalanced!</b></p>"
+    end
+
+    # Make sure it doesn't segfault
+    it "should be balanced correctly when run many times" do
+      text = <<-LATIN
+      Sequi unde et nobis ipsum. Expedita temporibus aut adipisci debitis
+      porro ducimus. Dignissimos est tenetur vero error voluptatem quidem
+      ducimus. Sapiente non occaecati omnis non provident sint ut. Repellat
+      laudantium quis aperiam ad fugit accusantium placeat itaque. Quia
+      velit voluptatem sint aliquid rem quam occaecati doloremque. Eos
+      provident ut suscipit reprehenderit mollitia. Non vitae voluptatem
+      laudantium quis a et. In libero voluptas aliquam.Veniam minima
+      consequatur quod. Voluptatem quibusdam ut consequatur et ratione
+      repellat. Iusto est aspernatur consequatur ex nostrum voluptas
+      voluptas et. Rerum voluptas et veritatis ratione voluptates ut iusto
+      ut. Aspernatur sed molestiae sint eveniet asperiores mollitia qui.
+        Rerum laudantium architecto soluta. Earum qui ut vel corporis ullam
+      doloribus voluptatem. Nemo quo recusandae ut. Deleniti vel ea qui ut
+      perferendis. Est dolor ducimus voluptatem nemo quis et animi
+      reprehenderit. Laudantium voluptas adipisci alias. Ut aut soluta
+      repellat consequuntur quidem. Deserunt voluptatem eum eveniet cum.Quia
+      consectetur at ut quisquam occaecati et sint. Sint voluptatem quaerat
+      qui molestiae ratione voluptatem. Autem labore quos perferendis enim
+      fuga deleniti recusandae. Aut libero quo cum autem voluptatem.
+      LATIN
+      2_000.times do
+        Pidgin2Adium.balance_tags_c("<p><b>#{text}").should == "<p><b>#{text}</b></p>"
+      end
+    end
+  end
+end

data/spec/basic_parser_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe "BasicParser" do
+  it "should include Pidgin2Adium" do
+    Pidgin2Adium::BasicParser.included_modules.include?(Pidgin2Adium).should be_true
+  end
+
+  describe "#parse" do
+    it "should return false" do
+      bp = Pidgin2Adium::BasicParser.new(@text_logfile_path,
+                                         @aliases)
+      bp.parse().should be_false
+    end
+  end
+
+  describe "#get_time_zone_offset" do
+    context "with no timezone available" do
+      it "should return the local time zone" do
+        bp = Pidgin2Adium::BasicParser.new(@text_logfile_path,
+                                           @aliases)
+        bp.get_time_zone_offset.should == @current_tz_offset
+      end
+    end
+
+    context "with a time zone available" do
+      it "should return the logfiles's time zone" do
+        bp = Pidgin2Adium::BasicParser.new(@html_logfile_path,
+                                           @aliases)
+        bp.get_time_zone_offset.should == "-0500"
+      end
+    end
+  end
+
+  describe "#create_adium_time" do
+    before(:each) do
+      @first_line_time = "4/18/2007 11:02:00 AM"
+      @time = "2007-08-20 12:33:13"
+      @minimal_time = "04:22:05 AM"
+      @minimal_time_2 = "04:22:05"
+      @invalid_time = "Hammer time!"
+
+      # Use HTML logfile because it has an explicit timezone (-0500), so we
+      # don't have to calculate it out.
+      @bp = Pidgin2Adium::BasicParser.new(@html_logfile_path,
+                                          @aliases)
+    end
+
+    it "should parse a first line time correctly" do
+      time = @bp.create_adium_time(@first_line_time, true)
+      time.should == "2007-04-18T11.02.00-0500"
+    end
+
+    it "should parse a normal time correctly" do
+      time = @bp.create_adium_time(@time)
+      time.should == "2007-08-20T12:33:13-0500"
+    end
+
+    it "should parse a minimal time correctly" do
+      time = @bp.create_adium_time(@minimal_time)
+      time.should == "2008-01-15T04:22:05-0500"
+    end
+
+    it "should parse a minimal time without AM/PM correctly" do
+      time = @bp.create_adium_time(@minimal_time_2)
+      time.should == "2008-01-15T04:22:05-0500"
+    end
+
+    it "should return an array of nils for an invalid time" do
+      time = @bp.create_adium_time(@invalid_time)
+      time.should be_nil
+    end
+  end
+
+  describe "#pre_parse" do
+    it "should raise an error for an invalid first line" do
+      bp =  Pidgin2Adium::BasicParser.new(
+              File.join(@current_dir,
+                        "logfiles",
+                        "invalid-first-line.txt"),
+              @aliases)
+      lambda do
+        bp.pre_parse()
+      end.should raise_error(Pidgin2Adium::InvalidFirstLineError)
+    end
+
+    it "should return correct info for an valid first line" do
+      bp =  Pidgin2Adium::BasicParser.new(@html_logfile_path,
+                                          @aliases)
+      results = bp.pre_parse()
+      results.should be_instance_of(Array)
+      results.should == ['aim', # service
+                         'othersn', # my SN
+                         'aolsystemmsg', # other person's SN
+                         {:year=>2008, :mon=>1, :mday=>15}, # basic time info
+                         '2008-01-15T07.14.45-0500' # chat start time
+                        ]
+    end
+  end
+
+  describe "#get_sender_by_alias" do
+    before(:each) do
+      @my_alias = "Gabe B-W"
+      @my_SN =  "awesomesn" # normalized from "awesome SN"
+
+      @partner_alias = "Leola Farber III"
+      @partner_SN = "BUDDY_PERSON" # not normalized
+      # Use text logfile since it has aliases set up.
+      @bp = Pidgin2Adium::BasicParser.new(@text_logfile_path,
+                                          @my_alias)
+    end
+
+    it "should return my SN when passed my alias" do
+      @bp.get_sender_by_alias(@my_alias).should == @my_SN
+    end
+
+    it "should return my SN when passed my alias with an action" do
+      @bp.get_sender_by_alias("***#{@my_alias}").should == @my_SN
+    end
+
+    it "should return partner's SN when passed partner's alias" do
+      @bp.get_sender_by_alias(@partner_alias).should == @partner_SN
+    end
+  end
+
+  describe "#create_msg" do
+    before(:each) do
+      body = "Your screen name (otherSN) is now signed into " +
+        "AOL(R) Instant Messenger (TM) in 2 locations. " +
+        "To sign off the other location(s), reply to this message " + "with the number 1. Click " +
+        "<a href='http://www.aim.com/password/routing.adp'>here</a> " +
+        "for more information."
+      @matches = ['2008-01-15T07.14.45-0500', # time
+                  'AOL System Msg', # alias
+                  nil, # not an auto-reply
+                  body # message body
+                 ]
+      @auto_reply_matches = @matches.dup
+      @auto_reply_matches[2] = '<AUTO-REPLY>'
+
+      @bp = Pidgin2Adium::BasicParser.new(@text_logfile_path,
+                                          "Gabe B-W")
+    end
+
+
+    it "should return XMLMessage class for a normal message" do
+      @bp.create_msg(@matches).should
+        be_instance_of(Pidgin2Adium::XMLMessage)
+    end
+
+    it "should return AutoReplyMessage class for an auto reply" do
+      @bp.create_msg(@auto_reply_matches).should
+        be_instance_of(Pidgin2Adium::AutoReplyMessage)
+    end
+
+    it "should return nil if the time is nil" do
+      @matches[0] = nil
+      @bp.create_msg(@matches).should be_nil
+    end
+  end
+
+  describe "#create_status_or_event_msg" do
+    before(:each) do
+      # not yet converted to Adium format
+      @time = "2007-08-20 12:33:13"
+      @alias = "Gabe B-W"
+      @status_map = {
+        "#{@alias} logged in." => 'online',
+        "#{@alias} logged out." => 'offline',
+        "#{@alias} has signed on." => 'online',
+        "#{@alias} has signed off." => 'offline',
+        "#{@alias} has gone away." => 'away',
+        "#{@alias} is no longer away." => 'available',
+        "#{@alias} has become idle." => 'idle',
+        "#{@alias} is no longer idle." => 'available'
+      }
+
+      # Small subset of all events
+      @libpurple_event_msg = "Starting transfer of cute kitties.jpg from Gabe B-W"
+      @event_msg =  "You missed 8 messages from Gabe B-W because they were too large"
+      @event_type = 'chat-error'
+
+      @ignored_event_msg = "Gabe B-W is now known as gbw.<br/>"
+
+      @bp = Pidgin2Adium::BasicParser.new(@html_logfile_path,
+                                          @alias)
+    end
+
+    it "should map statuses correctly" do
+      @status_map.each do |message, status|
+        return_value = @bp.create_status_or_event_msg([@time,
+                                                     message])
+        return_value.should be_instance_of(Pidgin2Adium::StatusMessage)
+        return_value.status.should == status
+      end
+    end
+
+    it "should map libpurple events correctly" do
+      return_val = @bp.create_status_or_event_msg([@time,
+                                                  @libpurple_event_msg])
+      return_val.should be_instance_of(Pidgin2Adium::Event)
+      return_val.event_type.should == 'libpurpleEvent'
+    end
+
+    it "should map non-libpurple events correctly" do
+      return_val = @bp.create_status_or_event_msg([@time,
+                                                  @event_msg])
+      return_val.should be_instance_of(Pidgin2Adium::Event)
+      return_val.event_type.should == @event_type
+    end
+
+    it "should return nil for ignored events" do
+      return_val = @bp.create_status_or_event_msg([@time,
+                                                  @ignored_event_msg])
+      return_val.should be_nil
+    end
+  end
+end