pipio 0.0.1

data/lib/pipio/message_creators/auto_or_xml_message_creator.rb

@@ -0,0 +1,25 @@
+module Pipio
+  class AutoOrXmlMessageCreator
+    def initialize(text, time, sender_screen_name, sender_alias, is_auto_reply)
+      @text = text
+      @time = time
+      @sender_screen_name = sender_screen_name
+      @sender_alias = sender_alias
+      @is_auto_reply = is_auto_reply
+    end
+
+    def create
+      if auto_reply?
+        AutoReplyMessage.new(@sender_screen_name, @time, @sender_alias, @text)
+      else
+        XMLMessage.new(@sender_screen_name, @time, @sender_alias, @text)
+      end
+    end
+
+    private
+
+    def auto_reply?
+      !! @is_auto_reply
+    end
+  end
+end

data/lib/pipio/message_creators/event_message_creator.rb

@@ -0,0 +1,47 @@
+module Pipio
+  class EventMessageCreator
+    def initialize(text, time, sender_alias, sender_screen_name, alias_registry)
+      @text = text
+      @time = time
+      @sender_alias = sender_alias
+      @sender_screen_name = sender_screen_name
+      @alias_registry = alias_registry
+    end
+
+    def create
+      create_lib_purple_event_message ||
+        create_non_lib_purple_event_message
+    end
+
+    private
+
+    def create_lib_purple_event_message
+      regex = Event::LIB_PURPLE.detect { |rxp| @text =~ rxp }
+      if regex
+        event_type = 'libpurpleEvent'
+        create_event_message_from(regex, event_type)
+      end
+    end
+
+    def create_non_lib_purple_event_message
+      regex, event_type = Event::MAP.detect { |rxp,ev_type| @text =~ rxp }
+      if regex && event_type
+        create_event_message_from(regex, event_type)
+      end
+    end
+
+    def create_event_message_from(regex, event_type)
+      regex_matches = regex.match(@text)
+      if regex_matches.size == 1
+        # No alias - this means it's the user
+        sender_alias = @sender_alias
+        sender_screen_name = @sender_screen_name
+      else
+        sender_alias = regex_matches[1]
+        sender_screen_name = @alias_registry[sender_alias]
+      end
+
+      Event.new(sender_screen_name, @time, sender_alias, @text, event_type)
+    end
+  end
+end

data/lib/pipio/message_creators/status_message_creator.rb

@@ -0,0 +1,19 @@
+module Pipio
+  class StatusMessageCreator
+    def initialize(text, time, alias_registry)
+      @text = text
+      @time = time
+      @alias_registry = alias_registry
+    end
+
+    def create
+      regex, status = StatusMessage::MAP.detect { |rxp, stat| @text =~ rxp }
+
+      if regex && status
+        sender_alias = regex.match(@text)[1]
+        sender_screen_name = @alias_registry[sender_alias]
+        StatusMessage.new(sender_screen_name, @time, sender_alias, status)
+      end
+    end
+  end
+end

data/lib/pipio/messages/auto_reply_message.rb

@@ -0,0 +1,7 @@
+module Pipio
+  class AutoReplyMessage < XMLMessage
+    def to_s
+      %(<message sender="#{sender_screen_name}" time="#{adium_formatted_time}" auto="true" alias="#{@sender_alias}">#{@styled_body}</message>\n)
+    end
+  end
+end

data/lib/pipio/messages/event.rb

@@ -0,0 +1,67 @@
+module Pipio
+  # 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
+    # All of event_type libPurple.
+    LIB_PURPLE = [
+      # file transfer
+      /Starting transfer of .+ from (.+)/,
+      /^Offering to send .+ to (.+)$/,
+      /(.+) is offering to send file/,
+      /^Transfer of file .+ complete$/,
+      /Error reading|writing|accessing .+: .+/,
+      /You cancell?ed the transfer of/,
+      /File transfer cancelled/,
+      /(.+?) cancell?ed the transfer of/,
+      /(.+?) cancelled the file transfer/,
+      # Direct IM - actual (dis)connect events are their own types
+      /^Attempting to connect to (.+) at .+ for Direct IM\./,
+      /^Asking (.+) to connect to us at .+ for Direct IM\./,
+      /^Attempting to connect via proxy server\.$/,
+      /^Direct IM with (.+) failed/,
+      # encryption
+      /Received message encrypted with wrong key/,
+      /^Requesting key\.\.\.$/,
+      /^Outgoing message lost\.$/,
+      /^Conflicting Key Received!$/,
+      /^Error in decryption- asking for resend\.\.\.$/,
+      /^Making new key pair\.\.\.$/,
+      # sending errors
+      /^Last outgoing message not received properly- resetting$/,
+      /Resending\.\.\./,
+      # connection errors
+      /Lost connection with the remote user:.+/,
+      # chats
+      /^.+ entered the room\.$/,
+      /^.+ left the room\.$/
+    ]
+
+    # Adium ignores SN/alias changes.
+    IGNORE = [/^.+? is now known as .+?\.<br\/?>$/]
+
+    # Each key maps to an event_type string. The keys will be matched against
+    # a line of chat and the partner's alias will be in regex group 1, IF the
+    # alias is matched.
+    MAP = {
+      # .+ is not an alias, it's a proxy server so no grouping
+      /^Attempting to connect to .+\.$/ => 'direct-im-connect',
+      # NB: pidgin doesn't track when Direct IM is disconnected, AFAIK
+      /^Direct IM established$/ => 'directIMConnected',
+      /Unable to send message/ => 'chat-error',
+      /You missed .+ messages from (.+) because they were too large/ => 'chat-error',
+      /User information not available/ => 'chat-error'
+    }
+
+    def initialize(sender_screen_name, time, sender_alias, body, event_type)
+      super(sender_screen_name, time, sender_alias, body)
+      @event_type = event_type
+    end
+
+    attr_reader :event_type
+
+    def to_s
+      %(<event type="#{@event_type}" sender="#{@sender_screen_name}" time="#{adium_formatted_time}" alias="#{@sender_alias}">#{@styled_body}</event>)
+    end
+  end
+end

data/lib/pipio/messages/message.rb

@@ -0,0 +1,23 @@
+module Pipio
+  # 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.
+  class Message
+    include Comparable
+
+    def initialize(sender_screen_name, time, sender_alias)
+      @sender_screen_name = sender_screen_name
+      @time = time
+      @sender_alias = sender_alias
+    end
+
+    attr_reader :sender_screen_name, :time, :sender_alias
+
+    private
+
+    def adium_formatted_time
+      @time.xmlschema
+    end
+  end
+end

data/lib/pipio/messages/status_message.rb

@@ -0,0 +1,26 @@
+module Pipio
+  # A message saying e.g. "Blahblah has gone away."
+  class StatusMessage < Message
+    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'
+    }
+
+    def initialize(sender_screen_name, time, sender_alias, status)
+      super(sender_screen_name, time, sender_alias)
+      @status = status
+    end
+
+    attr_reader :status
+
+    def to_s
+      %(<status type="#{@status}" sender="#{@sender_screen_name}" time="#{adium_formatted_time}" alias="#{@sender_alias}"/>\n)
+    end
+  end
+end

data/lib/pipio/messages/xml_message.rb

@@ -0,0 +1,43 @@
+module Pipio
+  # Basic message with body text (as opposed to pure status messages, which
+  # have no body).
+  class XMLMessage < Message
+    def initialize(sender_screen_name, time, sender_alias, body)
+      super(sender_screen_name, time, sender_alias)
+      @body = normalize(body)
+      @styled_body = %(<div><span style="font-family: Helvetica; font-size: 12pt;">#{@body}</span></div>)
+    end
+
+    attr_reader :body
+
+    def to_s
+      %(<message sender="#{@sender_screen_name}" time="#{adium_formatted_time}" alias="#{@sender_alias}">#{@styled_body}</message>\n)
+    end
+
+    private
+
+    # 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(string)
+      new_body = normalize_entities(string)
+      # Fix mismatched tags. Yes, it's faster to do it per-message
+      # than all at once.
+      new_body = Pipio::TagBalancer.new(new_body).balance
+      if @sender_alias[0,3] == '***'
+        # "***<alias>" is what pidgin sets as the alias for a /me action
+        @sender_alias.slice!(0,3)
+        new_body = "*#{new_body}*"
+      end
+
+      new_body
+    end
+
+    # Escapes all entities in string except for "&lt;", "&gt;", "&amp;", "&quot;",
+    # and "&apos;".
+    def normalize_entities(string)
+      # Convert '&' to '&amp;' only if it's not followed by an entity.
+      string.gsub(/&(?!lt|gt|amp|quot|apos)/, '&amp;')
+    end
+  end
+end

data/lib/pipio/metadata.rb

@@ -0,0 +1,34 @@
+module Pipio
+  class Metadata
+    def initialize(metadata_hash)
+      @service = metadata_hash[:service]
+      @my_screen_name = normalize_screen_name(metadata_hash[:my_screen_name])
+      @their_screen_name = metadata_hash[:their_screen_name]
+      @start_time = metadata_hash[:start_time]
+    end
+
+    attr_reader :my_screen_name, :their_screen_name, :start_time, :service
+
+    def valid?
+      [@their_screen_name, @my_screen_name, @start_time, @service].all?
+    end
+
+    def start_year
+      @start_time.year
+    end
+
+    def start_month
+      @start_time.mon
+    end
+
+    def start_mday
+      @start_time.mday
+    end
+
+    private
+
+    def normalize_screen_name(screen_name)
+      screen_name && screen_name.downcase.gsub(' ', '')
+    end
+  end
+end

data/lib/pipio/metadata_parser.rb

@@ -0,0 +1,55 @@
+module Pipio
+  class MetadataParser
+    def initialize(first_line)
+      @first_line = first_line || ''
+    end
+
+    def parse
+      {
+        my_screen_name: my_screen_name,
+        their_screen_name: their_screen_name,
+        start_time: start_time,
+        service: service
+      }
+    end
+
+    private
+
+    def service
+      match = @first_line.match(/\(([a-z]+)\)/)
+      if match
+        match[1]
+      end
+    end
+
+    def their_screen_name
+      match = @first_line.match(/Conversation with (.+?) at/)
+      if match
+        match[1]
+      end
+    end
+
+    def my_screen_name
+      match = @first_line.match(/ on ([^()]+) /)
+      if match
+        match[1]
+      end
+    end
+
+    def start_time
+      match = @first_line.match(%r{ at ([-\d/APM: ]+) on})
+      if match
+        timestamp = match[1]
+        parse_time(timestamp)
+      end
+    end
+
+    def parse_time(timestamp)
+      begin
+        Time.parse(timestamp)
+      rescue ArgumentError
+        TimeParser.new(nil, nil, nil).parse(timestamp)
+      end
+    end
+  end
+end

data/lib/pipio/parser_factory.rb

@@ -0,0 +1,32 @@
+module Pipio
+  class ParserFactory
+    PARSER_FOR_EXTENSION = {
+      "html" => HtmlLogParser,
+      "htm" => HtmlLogParser,
+      "txt" => TextLogParser
+    }
+
+    def initialize(logfile_path, aliases)
+      @logfile_path = logfile_path
+      @aliases = aliases
+    end
+
+    def parser
+      parser_class.new(@logfile_path, @aliases)
+    end
+
+    private
+
+    def parser_class
+      PARSER_FOR_EXTENSION.fetch(extension, NullParser)
+    end
+
+    def extension
+      extension_with_leading_period[1..-1]
+    end
+
+    def extension_with_leading_period
+      File.extname(@logfile_path).downcase
+    end
+  end
+end

data/lib/pipio/parsers/basic_parser.rb

@@ -0,0 +1,83 @@
+module Pipio
+  class BasicParser
+    def initialize(source_file_path, my_aliases, line_regex, line_regex_status, cleaner)
+      @my_aliases = my_aliases.split(',')
+      @line_regex = line_regex
+      @line_regex_status = line_regex_status
+      @my_alias = @my_aliases.first
+
+      @file_reader = FileReader.new(source_file_path, cleaner)
+    end
+
+    # This method returns a Chat instance, or false if it could not parse the
+    # file.
+    def parse
+      if pre_parse
+        messages = @file_reader.other_lines.map do |line|
+          basic_message_match =  @line_regex.match(line)
+          meta_message_match = @line_regex_status.match(line)
+          if basic_message_match
+            create_message(basic_message_match)
+          elsif meta_message_match
+            create_status_or_event_message(meta_message_match)
+          end
+        end
+
+        Chat.new(messages, @metadata)
+      end
+    end
+
+    # Extract required data from the file. Run by parse.
+    def pre_parse
+      @file_reader.read
+      metadata = Metadata.new(MetadataParser.new(@file_reader.first_line).parse)
+      if metadata.valid?
+        @metadata = metadata
+        @alias_registry = AliasRegistry.new(@metadata.their_screen_name)
+        @my_aliases.each do |my_alias|
+          @alias_registry[my_alias] = @metadata.my_screen_name
+        end
+      end
+    end
+
+    def create_message(match_data)
+      # Either a regular message line or an auto-reply/away message.
+      time = time_parser.parse(match_data[:timestamp])
+      if time
+        my_alias = match_data[:sn_or_alias]
+        my_screen_name = @alias_registry[my_alias]
+        body = match_data[:body]
+        is_auto_reply = match_data[:auto_reply]
+
+        AutoOrXmlMessageCreator.new(body, time, my_screen_name, my_alias, is_auto_reply).create
+      end
+    end
+
+    def create_status_or_event_message(match_data)
+      time = time_parser.parse(match_data[:timestamp])
+      str = match_data[:body]
+
+      if time && event_we_care_about?(str)
+        create_status_message(str, time) || create_event_message(str, time)
+      end
+    end
+
+    def time_parser
+      @time_parser ||= TimeParser.new(@metadata.start_year, @metadata.start_month, @metadata.start_mday)
+    end
+
+    private
+
+    def event_we_care_about?(str)
+      Event::IGNORE.none? { |regex| str =~ regex }
+    end
+
+    def create_event_message(text, time)
+      EventMessageCreator.new(text, time, @my_alias, @metadata.my_screen_name, @alias_registry).create
+    end
+
+    def create_status_message(text, time)
+      StatusMessageCreator.new(text, time, @alias_registry).create
+    end
+  end
+end