pidgin2adium 3.3.0 → 4.0.0.beta1

data/lib/pidgin2adium/parsers/html_log_parser.rb

@@ -1,125 +0,0 @@
-# HtmlLogParser class, a subclass of BasicParser.
-# Used for parse()ing HTML logs.
-
-require 'balance_tags_c'
-
-module Pidgin2Adium
-  class HtmlLogParser < BasicParser
-    def initialize(src_path, user_aliases, force_conversion = false)
-      super(src_path, user_aliases, force_conversion)
-      @timestamp_rx = '\(((?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{1,2}:\d{1,2}(?: [AP]M)?)\)'
-
-      # @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: screen name or alias, if alias set
-      # 2: "&lt;AUTO-REPLY&gt;" or nil
-      # 3: message body
-      # The ":" is optional to allow for strings like "(17:12:21) <b>***Gabe B-W</b> is confused<br/>"
-      @line_regex = /#{@timestamp_rx} ?<b>(.+?) ?(&lt;AUTO-REPLY&gt;)?:?<\/b> ?(.+)<br ?\/>/o
-      # @line_regex_status matches a status line
-      # @line_regex_status match obj:
-      # 0: timestamp
-      # 1: status message
-      @line_regex_status = /#{@timestamp_rx} ?<b> (.+)<\/b><br ?\/>/o
-    end
-
-    # Returns a cleaned string.
-    # Removes the following tags from _text_:
-    # * html
-    # * body
-    # * font
-    # * a with no innertext, e.g. <a href="blah"></a>
-    # And removes the following style declarations:
-    # * color: #000000 (just turns text black)
-    # * font-family
-    # * font-size
-    # * background
-    # * em (really it's changed to <span style="font-style: italic;">)
-    # Since each <span> has only one style declaration, spans with these
-    # declarations are removed (but the text inside them is preserved).
-    def cleanup(text)
-      # Sometimes this is in there. I don't know why.
-      text.gsub!(%r{&lt;/FONT HSPACE='\d'>}, '')
-      # We can remove <font> safely since Pidgin and Adium both show bold
-      # using <span style="font-weight: bold;"> except Pidgin uses single
-      # quotes while Adium uses double quotes.
-      text.gsub!(/<\/?(?:html|body|font)(?: .+?)?>/, '') # very important!
-
-      text.tr!("\r", '')
-      # Remove empty lines
-      text.gsub!("\n\n", "\n")
-
-      # Remove newlines that end the file, since they screw up the
-      # newline -> <br/> conversion
-      text.gsub!(/\n\Z/, '')
-
-      # Replace newlines with "<br/>" unless they end a chat line.
-      # This must go after we remove <font> tags.
-      text.gsub!(/\n(?!#{@timestamp_rx})/, '<br/>')
-
-      # These empty links are sometimes appended to every line in a chat,
-      # for some weird reason. Remove them.
-      text.gsub!(%r{<a href=['"].+?['"]>\s*?</a>}, '')
-
-      # Replace single quotes inside tags with double quotes so we can
-      # easily change single quotes to entities.
-      # For spans, removes a space after the final declaration if it exists.
-      text.gsub!(/<span style='([^']+?;) ?'>/, '<span style="\1">')
-      text.gsub!(/([a-z]+=)'(.+?)'/, '\1"\2"')
-=begin
-      text.gsub!(/<a href='(.+?)'>/, '<a href="\1">')
-      text.gsub!(/<img src='([^']+?)'/, '<img src="\1"')
-      text.gsub!(/ alt='([^']+?)'/, ' alt="\1"')
-=end
-      text.gsub!("'", '&apos;')
-
-      # This actually does match stuff, but doesn't group it correctly. :(
-      # text.gsub!(%r{<span style="((?:.+?;)+)">(.*?)</span>}) do |s|
-      text.gsub!(%r{<span style="(.+?)">(.*?)</span>}) do |s|
-        # Remove empty spans.
-        next if $2 == ''
-
-        # style = style declaration
-        # innertext = text inside <span>
-        style, innertext = $1, $2
-        # TODO: replace double quotes with "&quot;", but only outside tags; may still be tags inside spans
-        # innertext.gsub!("")
-
-        styleparts = style.split(/; ?/)
-        styleparts.map! do |p|
-          if p[0,5] == 'color'
-            if p.include?('color: #000000')
-              next
-            elsif p =~ /(color: #[0-9a-fA-F]{6})(>.*)?/
-              # Regarding the bit with the ">", sometimes this happens:
-              # <span style="color: #000000>today;">today was busy</span>
-              # Then p = "color: #000000>today"
-              # Or it can end in ">;", with no text before the semicolon.
-              # So keep the color but remove the ">" and anything following it.
-              next($1)
-            end
-          else
-            # don't remove font-weight
-            case p
-            when /^font-family/ then next
-            when /^font-size/ then next
-            when /^background/ then next
-            end
-          end
-        end.compact!
-        unless styleparts.empty?
-          style = styleparts.join('; ')
-          innertext = "<span style=\"#{style};\">#{innertext}</span>"
-        end
-        innertext
-      end
-      # Pidgin uses <em>, Adium uses <span>
-      if text.gsub!('<em>', '<span style="font-style: italic;">')
-        text.gsub!('</em>', '</span>')
-      end
-      return text
-    end
-  end # END HtmlLogParser class
-end

data/lib/pidgin2adium/parsers/text_log_parser.rb

@@ -1,39 +0,0 @@
-# TextLogParser class, a subclass of BasicParser.
-# Used for parse()ing text logs.
-
-module Pidgin2Adium
-  class TextLogParser < BasicParser
-    def initialize(src_path, user_aliases, force_conversion = false)
-      super(src_path, user_aliases, force_conversion)
-      @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/spec/balance_tags_c_extn_spec.rb

@@ -1,47 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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 "#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)
-      time.should =~ /2007-04-18T11:02:00[-+]\d{2}:00/
-    end
-
-    it "should parse a normal time correctly" do
-      time = @bp.create_adium_time(@time)
-      time.should =~ /2007-08-20T12:33:13[-+]\d{2}:00/
-    end
-
-    it "should parse a minimal time correctly" do
-      time = @bp.create_adium_time(@minimal_time)
-      time.should =~ /2008-01-15T04:22:05[-+]\d{2}:00/
-    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[-+]\d{2}:00/
-    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 true when everything can be parsed" do
-      bp =  Pidgin2Adium::BasicParser.new(@html_logfile_path,
-                                          @aliases)
-      bp.pre_parse!.should be_true
-    end
-
-    describe "correctly setting variables" do
-      before do
-        @bp =  Pidgin2Adium::BasicParser.new(@html_logfile_path, @aliases)
-        @bp.pre_parse!()
-      end
-
-      it "should correctly set @service" do
-        @bp.instance_variable_get('@service').should == 'aim'
-      end
-
-      it "should correctly set user_SN" do
-        @bp.instance_variable_get('@user_SN').should == 'othersn'
-      end
-
-      it "should correctly set partner_SN" do
-        @bp.instance_variable_get('@partner_SN').should == 'aolsystemmsg'
-      end
-
-      it "should correctly set basic_time_info" do
-        @bp.instance_variable_get('@basic_time_info').should == {:year=>2008, :mon=>1, :mday=>15}
-      end
-
-      it "should correctly set adium_chat_time_start" do
-        @bp.instance_variable_get('@adium_chat_time_start').should == '2008-01-15T07:14:45-05:00'
-      end
-    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-05:00', # 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

data/spec/html_log_parser_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-
-describe "HtmlLogParser" do
-  before(:each) do
-    # @year, @am, and @pm are not required. @time is.
-    # So @year + @time is a valid time,
-    # as is @time, and @year + @time + @am.
-    @year = '2007-10-28 '
-    @time = '4:46:20'
-    @am = ' AM'
-    @pm = ' PM'
-    @hlp = Pidgin2Adium::HtmlLogParser.new(@html_logfile_path,
-                                           @aliases)
-    @clean = "clean"
-  end
-
-  it "should have Pidgin2Adium.balance_tags_c available" do
-    Pidgin2Adium.should respond_to(:balance_tags_c)
-  end
-
-  describe "#cleanup" do
-    it "should remove html, body, and font tags" do
-      dirty_text = %Q{<html><body type="ichat"><font color="red">#{@clean}</font></body></html>}
-      @hlp.cleanup(dirty_text).should == @clean
-    end
-
-    it "should remove those weird <FONT HSPACE> tags" do
-      dirty = %Q{&lt;/FONT HSPACE='2'>#{@clean}}
-      @hlp.cleanup(dirty).should == @clean
-    end
-
-    it "should remove \\r" do
-      dirty = [@clean, @clean, @clean].join("\r")
-      @hlp.cleanup(dirty).should == @clean * 3
-    end
-
-    it "should remove empty lines" do
-      dirty = "#{@clean}\n\n"
-      @hlp.cleanup(dirty).should == @clean
-    end
-
-    it "should replace newlines with <br/>" do
-      dirty = "\n#{@clean}"
-      @hlp.cleanup(dirty).should == "<br/>#{@clean}"
-    end
-
-    it "should remove empty links" do
-      dirty = %Q{<a href="awesomelink">   </a>#{@clean}}
-      dirty += %Q{<a href='awesomelink'></a>#{@clean}}
-      @hlp.cleanup(dirty).should == @clean + @clean
-    end
-
-    describe "with <span>s" do
-      it "should remove font-family" do
-        dirty = %Q{<span style='font-family: Helvetica;'>#{@clean}</span>}
-        @hlp.cleanup(dirty).should == @clean
-      end
-
-      it "should remove font-size" do
-        dirty = %Q{<span style="font-size: 6;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == @clean
-      end
-
-      it "should remove background" do
-        dirty = %Q{<span style="background: #00afaf;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == @clean
-      end
-
-      it "should remove color=#00000" do
-        dirty = %Q{<span style="color: #000000;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == @clean
-      end
-
-      it "should not remove color != #00000" do
-        dirty = %Q{<span style="color: #01ABcdef;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == dirty
-      end
-
-      it "should remove improperly-formatted colors" do
-        dirty = %Q{<span style="color: #0;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == @clean
-      end
-
-      it "should replace <em> with italic font-style" do
-        dirty = "<em>#{@clean}</em>"
-        clean = %Q{<span style="font-style: italic;">#{@clean}</span>}
-        @hlp.cleanup(dirty).should == clean
-      end
-
-      it "shouldn't modify clean text" do
-        @hlp.cleanup(@clean).should == @clean
-      end
-
-      # This implicitly tests a lot of other things, but they've been tested
-      # before this too.
-      it "should remove a trailing space after style declaration and replace double quotes" do
-        dirty_span_open = "<span style='color: #afaf00; font-size: 14pt; font-weight: bold; '>"
-        # Replaced double quotes, removed space before ">"
-        clean_span_open = '<span style="color: #afaf00;">'
-        dirty = dirty_span_open + @clean + "</span>"
-        @hlp.cleanup(dirty).should == clean_span_open + @clean + "</span>"
-      end
-    end
-  end
-
-  describe "#parse" do
-    before(:each) do
-      @logfile = @hlp.parse()
-    end
-
-    it "should return a LogFile instance" do
-      @logfile.should be_instance_of(Pidgin2Adium::LogFile)
-    end
-
-    it "should return a LogFile with the correct number of chat_lines" do
-      @logfile.chat_lines.size.should == 3
-    end
-
-    it "should return a LogFile with the correct message type" do
-      @logfile.chat_lines.map{|x| x.class }.should == [Pidgin2Adium::XMLMessage] * 3
-    end
-
-    it "should return a LogFile with the correct data" do
-      first_msg = @logfile.chat_lines[0]
-      second_msg = @logfile.chat_lines[1]
-      third_msg = @logfile.chat_lines[2]
-
-      first_msg.sender.should == "aolsystemmsg"
-      first_msg.buddy_alias.should == "AOL System Msg"
-      # Use regex to ignore time zone
-      first_msg.time.should =~ /^2008-01-15T07:14:45[-+]\d{2}:00$/
-      # This fails due to balance_tags_c().
-      good_body = %Q{Your screen name (otherSN) is now signed into AOL(R) Instant Messenger (TM) in 2 locations.} + " " +
-        %Q{To sign off the other location(s), reply to this message with the number 1.} + " " +
-        %Q{Click <a href="http://www.aim.com/password/routing.adp">here</a> for more information.}
-      first_msg.body.should == good_body
-
-      second_msg.sender.should == "othersn"
-      second_msg.buddy_alias.should == "Gabe B-W"
-      second_msg.time.should =~ /^2008-01-15T07:14:48[-+]\d{2}:00$/
-      second_msg.body.should == "1"
-
-      third_msg.sender.should == "aolsystemmsg"
-      third_msg.buddy_alias.should == "AOL System Msg"
-      # Use regex to ignore time zone
-      third_msg.time.should =~ /^2008-01-15T07:14:48[-+]\d{2}:00$/
-      third_msg.body.should == "Your other AIM sessions have been signed-off.  You are now signed-on from 1 location(s)."
-    end
-  end
-end