pipio 0.0.1

data/spec/pipio/parser_factory_spec.rb

@@ -0,0 +1,31 @@
+describe Pipio::ParserFactory do
+  let(:aliases) { '' }
+
+  %w(html htm HTML).each do |html_extension|
+    context "when passed a .#{html_extension} file" do
+      it 'returns an HtmlLogParser' do
+        logfile_path = "whatever.#{html_extension}"
+        factory = Pipio::ParserFactory.new(logfile_path, aliases)
+        expect(factory.parser).to be_a Pipio::HtmlLogParser
+      end
+    end
+  end
+
+  %w(txt TXT).each do |text_extension|
+    context "when passed a .#{text_extension} file" do
+      it 'returns a TextLogParser' do
+        logfile_path = "whatever.#{text_extension}"
+        factory = Pipio::ParserFactory.new(logfile_path, aliases)
+        expect(factory.parser).to be_a Pipio::TextLogParser
+      end
+    end
+  end
+
+  context 'when passed a non-HTML, non-text file' do
+    it 'returns something that responds to parse' do
+      other_path = 'foo.bar'
+      factory = Pipio::ParserFactory.new(other_path, aliases)
+      expect(factory.parser).to respond_to(:parse)
+    end
+  end
+end

data/spec/pipio/parsers/html_log_parser_spec.rb

@@ -0,0 +1,160 @@
+describe Pipio::HtmlLogParser do
+  context '#parse' do
+    it 'returns a Chat with the correct number of lines' do
+      chat = build_chat do |b|
+        b.first_line
+        3.times { b.message }
+      end
+
+      expect(chat.messages.size).to eq(3)
+    end
+
+    it 'returns a Chat with the correct message type' do
+      chat = build_chat do |b|
+        b.first_line
+        b.message 'first'
+        b.message 'second'
+      end
+
+      expect(chat.messages.map(&:class)).to eq([Pipio::XMLMessage] * 2)
+    end
+
+    {
+      'Gabe B-W logged in.' => 'online',
+      'Gabe B-W logged out.' => 'offline',
+      'Gabe B-W has signed on.' => 'online',
+      'Gabe B-W has signed off.' => 'offline',
+      'Gabe B-W has gone away.' => 'away',
+      'Gabe B-W is no longer away.' => 'available',
+      'Gabe B-W has become idle.' => 'idle',
+      'Gabe B-W is no longer idle.' => 'available'
+    }.each do |line, status|
+      it "correctly detects status messages of format '#{line}'" do
+        message = first_line_of_chat do |b|
+          b.first_line
+          b.status line
+        end
+
+        expect(message.status).to eq(status)
+      end
+    end
+
+    it 'correctly detects libpurple events' do
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.status 'Starting transfer of kitten.jpg from Gabe B-W'
+      end
+
+      expect(message.event_type).to eq('libpurpleEvent')
+    end
+
+    it 'correctly detects non-libpurple events' do
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.status 'You missed 8 messages from Gabe B-W because they were too large'
+      end
+
+      expect(message.event_type).to eq('chat-error')
+    end
+
+    it 'does not build Messages for ignored events' do
+      chat = build_chat do |b|
+        b.first_line
+        b.status 'Gabe B-W is now known as gbw.'
+      end
+
+      expect(chat.messages).to eq([nil])
+    end
+
+    it 'correctly detects auto-reply messages' do
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.auto_reply 'I ran out for a bit'
+      end
+
+      expect(message).to be_instance_of(Pipio::AutoReplyMessage)
+      expect(message.body).to eq('I ran out for a bit')
+    end
+
+    it 'parses out the screen name for the user who is doing the logging' do
+      message = first_line_of_chat('Gabe B-W') do |b|
+        b.first_line from: 'from', to: 'to'
+        b.message 'whatever', from: 'from', from_alias: 'Gabe B-W'
+      end
+
+      expect(message.sender_screen_name).to eq('from')
+    end
+
+    it 'parses out the alias for the user who is doing the logging' do
+      message = first_line_of_chat do |b|
+        b.first_line from: 'from', to: 'to'
+        b.message 'whatever', from_alias: 'Jack Alias'
+      end
+
+      expect(message.sender_alias).to eq('Jack Alias')
+    end
+
+    it 'parses out the screen name for the user on the other end' do
+      message = first_line_of_chat('my-alias') do |b|
+        b.first_line from: 'from'
+        b.message 'whatever', from: 'from', from_alias: 'my-alias'
+      end
+
+      expect(message.sender_screen_name).to eq('from')
+    end
+
+    it 'parses out the alias for the user on the other end' do
+      message = first_line_of_chat('my-alias') do |b|
+        b.first_line from: 'from'
+        b.message 'whatever', from: 'from', from_alias: 'my-alias'
+      end
+
+      expect(message.sender_alias).to eq('my-alias')
+    end
+
+    it 'parses out the time' do
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.message 'whatever', time: '2008-01-15 07:14:45'
+      end
+
+      expect(message.time).to eq(Time.parse('2008-01-15 07:14:45'))
+    end
+
+    it 'parses out the body' do
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.message 'body'
+      end
+
+      expect(message.body).to eq('body')
+    end
+
+    it 'double quotes hrefs in the body' do
+      body_with_link = %q(<a href='http://google.com'>first</a>)
+      message = first_line_of_chat do |b|
+        b.first_line
+        b.message body_with_link
+      end
+
+      expect(message.body).to eq(body_with_link.gsub("'", '"'))
+    end
+
+    it 'has access to the screen name of the other person' do
+      chat = build_chat do |b|
+        b.first_line to: 'person_on_the_other_end'
+      end
+
+      expect(chat.their_screen_name).to eq('person_on_the_other_end')
+    end
+  end
+
+  def build_chat(aliases = 'Gabe B-W', &block)
+    file = create_chat_file('file.html', &block)
+    Pipio::HtmlLogParser.new(file.path, aliases).parse
+  end
+
+  def first_line_of_chat(aliases = 'Gabe B-W', &block)
+    build_chat(aliases, &block).messages.first
+  end
+end

data/spec/pipio/parsers/null_parser_spec.rb

@@ -0,0 +1,13 @@
+describe Pipio::NullParser do
+  context '#parse' do
+    it 'does nothing' do
+      expect do
+        Pipio::NullParser.new('path/to/file', 'alias').parse
+      end.not_to raise_error
+    end
+
+    it 'returns falsy' do
+      expect(Pipio::NullParser.new('path/to/file', 'alias').parse).not_to be
+    end
+  end
+end

data/spec/pipio/parsers/text_log_parser_spec.rb

@@ -0,0 +1,37 @@
+describe Pipio::TextLogParser do
+  describe "#parse" do
+    it "returns a Chat with the correct number of lines" do
+      chat = build_chat do |b|
+        b.message
+      end
+
+      expect(chat.messages.size).to eq(1)
+    end
+
+    it "returns a Chat with the correct message type" do
+      chat = build_chat do |b|
+        b.message
+      end
+
+      expect(chat.messages.first).to be_instance_of(Pipio::XMLMessage)
+    end
+
+    it "returns a Chat with the correct data" do
+      message = build_chat do |b|
+        b.first_line time: '2006-12-21 22:36:06', from: 'awesome SN'
+        b.message from_alias: 'Gabe B-W', time: '22:36:11',
+          text: "what are you doing tomorrow?"
+      end.messages.first
+
+      expect(message.sender_screen_name).to eq("awesomesn")
+      expect(message.body).to eq("what are you doing tomorrow?")
+      expect(message.sender_alias).to eq("Gabe B-W")
+      expect(message.time).to eq(Time.parse('2006-12-21 22:36:11').utc)
+    end
+  end
+
+  def build_chat(aliases = 'Gabe B-W', &block)
+    path = create_chat_file('file.txt', &block).path
+    Pipio::TextLogParser.new(path, aliases).parse
+  end
+end

data/spec/pipio/tag_balancer_spec.rb

@@ -0,0 +1,16 @@
+describe Pipio::TagBalancer do
+  describe 'text without tags' do
+    it 'is left untouched' do
+      text = 'foo!'
+      expect(Pipio::TagBalancer.new(text).balance).to eq(text)
+    end
+  end
+
+  describe 'text with tags' do
+    it 'is balanced correctly' do
+      unbalanced = '<p><b>this is unbalanced!'
+      balanced = '<p><b>this is unbalanced!</b></p>'
+      expect(Pipio::TagBalancer.new(unbalanced).balance).to eq(balanced)
+    end
+  end
+end

data/spec/pipio/time_parser_spec.rb

@@ -0,0 +1,66 @@
+describe Pipio::TimeParser, "#parse" do
+  it 'returns nil when timestamp is nil' do
+    time_parser = Pipio::TimeParser.new(2011, 2, 3)
+
+    expect(time_parser.parse(nil)).to be_nil
+  end
+
+  context 'when the given timestamp does have a date' do
+    let(:time_parser) { Pipio::TimeParser.new(2011, 4, 28) }
+
+    it 'parses "%m/%d/%Y %I:%M:%S %P"' do
+      timestamp = '01/22/2008 03:01:45 PM'
+      result = time_parser.parse(timestamp)
+      expect(result.year).to eq(2008)
+      expect(result.mon).to eq(1)
+      expect(result.mday).to eq(22)
+      expect(result.hour).to eq(15)
+      expect(result.min).to eq(1)
+      expect(result.sec).to eq(45)
+    end
+
+    [
+      '%Y-%m-%d %H:%M:%S',
+      '%Y/%m/%d %H:%M:%S',
+      '%Y-%m-%d %H:%M:%S',
+      '%a %b %d %H:%M:%S %Y'
+    ].each do |format|
+      it "parses '#{format}'" do
+        time = Time.now
+        timestamp = time.strftime(format)
+        expect(time_parser.parse(timestamp)).to eq(Time.parse(timestamp))
+      end
+    end
+
+    it 'parses "%a %d %b %Y %H:%M:%S %p %Z", respecting TZ' do
+      timestamp = "Sat 18 Apr 2009 10:43:35 AM PDT"
+      time = Time.parse(timestamp)
+      expect(time.utc.hour).to eq(17)
+      expect(time_parser.parse(timestamp)).to eq(time)
+    end
+  end
+
+  context 'when the given timestamp does not have a date' do
+    let(:time_parser) { Pipio::TimeParser.new(2008, 4, 27) }
+
+    it 'parses "%I:%M:%S %P"' do
+      result = time_parser.parse('08:01:45 PM')
+      expect(result.year).to eq(2008)
+      expect(result.mon).to eq(4)
+      expect(result.mday).to eq(27)
+      expect(result.hour).to eq(20)
+      expect(result.min).to eq(1)
+      expect(result.sec).to eq(45)
+    end
+
+    it 'parses "%H:%M:%S"' do
+      result = time_parser.parse('23:01:45')
+      expect(result.year).to eq(2008)
+      expect(result.mon).to eq(4)
+      expect(result.mday).to eq(27)
+      expect(result.hour).to eq(23)
+      expect(result.min).to eq(1)
+      expect(result.sec).to eq(45)
+    end
+  end
+end

data/spec/pipio_spec.rb

@@ -0,0 +1,63 @@
+describe Pipio, ".parse" do
+  context "with bad input" do
+    it "returns false when file is not text or html" do
+      expect(Pipio.parse(non_html_or_txt_path, aliases)).to be_falsey
+    end
+
+    it "returns false for nonexistent files" do
+      expect(Pipio.parse('i_do_not_exist.html', aliases)).to be_falsey
+      expect(Pipio.parse('i_do_not_exist.txt', aliases)).to be_falsey
+    end
+
+    def non_html_or_txt_path
+      'logfile.foobar'
+    end
+  end
+
+  context "with good input" do
+    context "for a text file" do
+      it "returns a Chat instance" do
+        result = Pipio.parse(text_logfile_path, aliases)
+        expect(result).to be_instance_of(Pipio::Chat)
+      end
+    end
+
+    context "for an htm file" do
+      it "returns a Chat instance" do
+        result = Pipio.parse(htm_logfile_path, aliases)
+        expect(result).to be_instance_of(Pipio::Chat)
+      end
+    end
+
+    context "for an html file" do
+      it "returns a Chat instance" do
+        result = Pipio.parse(html_logfile_path, aliases)
+        expect(result).to be_instance_of(Pipio::Chat)
+      end
+    end
+  end
+
+  def spec_directory
+    File.dirname(__FILE__)
+  end
+
+  def logfile_path
+    Pathname.new(File.join(spec_directory, "support", "logfiles"))
+  end
+
+  def text_logfile_path
+    logfile_path.join("2006-12-21.223606.txt")
+  end
+
+  def htm_logfile_path
+    logfile_path.join("2008-01-15.071445-0500PST.htm")
+  end
+
+  def html_logfile_path
+    logfile_path.join("2008-01-15.071445-0500PST.html")
+  end
+
+  def aliases
+    ''
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+
+$LOAD_PATH.unshift(File.expand_path('..',  __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+
+require 'fileutils'
+require 'pipio'
+require 'mocha/api'
+
+Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/chat_builder.rb

@@ -0,0 +1,29 @@
+# Usage:
+# # determine format from passed-in file
+# ChatBuilder.new('file.html') do |b|
+#   b.first_line
+#   b.message from: 'name1', from_alias: 'Gabe B-W',
+#          time: '2010-01-30', text: 'blarg balrg'
+#   b.message 'blerg' from: 'name2',
+#     from_alias: 'another name', time: '2010-01-30'
+#   b.away_message
+#   b.status_message
+# end
+
+class ChatBuilder
+  DEFAULT_FROM = 'FROM_SN'
+
+  def initialize(file)
+    @file = file
+    @first_line = nil
+    @messages = []
+  end
+
+  def write(separator = "")
+    @file.puts(first_line)
+    @messages.each do |message|
+      @file.puts(message + separator)
+    end
+    @file.close
+  end
+end

data/spec/support/chat_builder_helpers.rb

@@ -0,0 +1,41 @@
+require File.expand_path('./file_builder', File.dirname(__FILE__))
+
+module ChatBuilderHelpers
+  SPEC_DIR = File.dirname(File.dirname(__FILE__))
+  TMP_DIRECTORY = File.join(SPEC_DIR, 'tmp')
+
+  def create_chat_file(file_name = 'whatever.txt')
+    file = FileBuilder.create_file(file_name)
+    correct_builder_for(file).tap do |builder|
+      yield builder if block_given?
+      builder.write
+    end
+    file
+  end
+
+  def clean_up_generated_chat_files
+    FileUtils.rm_rf(TMP_DIRECTORY)
+  end
+
+  private
+
+  def correct_builder_for(file)
+    if file.path =~ /\.html?$/
+      HtmlChatBuilder.new(file)
+    else
+      TextChatBuilder.new(file)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ChatBuilderHelpers
+
+  config.before do
+    FileUtils.mkdir_p(ChatBuilderHelpers::TMP_DIRECTORY)
+  end
+
+  config.after do
+    clean_up_generated_chat_files
+  end
+end