srt 0.0.10 → 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Mzk5Mjk2ZGU5NjI2NTZjYWVmN2JkN2E1MTY4ZjJkMmEzZmRmNzA5ZA==
+  data.tar.gz: !binary |-
+    MTIxY2EyYTczM2Q2NTg1NjZlZGNlNDQ4ZGQ4MDRmZDBmOWE3OTA1Yg==
+SHA512:
+  metadata.gz: !binary |-
+    MTQyM2M1Y2I4ZDY5MGJkNTk3MWVkNGJkNzk5ZWI5MTJkYjZkMjBiYzhmMDY0
+    YThlZDQyOWQ5YzRmYjNjODkwYjFmMGM4ZjQ1ZTgwN2QwMTJiOWM3Y2I0Y2M1
+    Njc4NTg5ZjI5ZTNiZTAxZjYzYzQzZjg2YmFjODY5NzUyOTVjOTE=
+  data.tar.gz: !binary |-
+    NzIyNzExYzBiMjYzZWMzOGVkZDMyZjhiN2EyNWNmNGZhNThhNzkwMDhmNGRk
+    NGE3ZTMxMjA5YmNlYjJmYmNmZmZmYTgwNDIzOWJkZjA2YzE2YzAyZThlOGY5
+    ZTNhYTBlN2ZiYmFlYmY2ZmM4NzI0ODc5NTg4MmFmNDY5YjE1NTE=

data/lib/srt.rb

@@ -1,3 +1,4 @@
 require "srt/file"
 require "srt/line"
-require "srt/version"
+require "srt/parser"
+require "srt/version"

data/lib/srt/file.rb

@@ -16,26 +16,26 @@ module SRT
     end
 
     def self.parse_string(srt_data)
-      result = SRT::File.new
-      line = SRT::Line.new
+      result = new
+      line = Line.new
 
       split_srt_data(srt_data).each_with_index do |str, index|
         begin
           if str.strip.empty?
             result.lines << line unless line.empty?
-            line = SRT::Line.new
+            line = Line.new
           elsif !line.error
             if line.sequence.nil?
               line.sequence = str.to_i
             elsif line.start_time.nil?
               if mres = str.match(/(?<start_timecode>[^[[:space:]]]+) -+> (?<end_timecode>[^[[:space:]]]+) ?(?<display_coordinates>X1:\d+ X2:\d+ Y1:\d+ Y2:\d+)?/)
 
-                if (line.start_time = SRT::File.parse_timecode(mres["start_timecode"])) == nil
+                if (line.start_time = Parser.timecode(mres["start_timecode"])) == nil
                   line.error = "#{index}, Invalid formatting of start timecode, [#{mres["start_timecode"]}]"
                   $stderr.puts line.error if @debug
                 end
 
-                if (line.end_time = SRT::File.parse_timecode(mres["end_timecode"])) == nil
+                if (line.end_time = Parser.timecode(mres["end_timecode"])) == nil
                   line.error = "#{index}, Invalid formatting of end timecode, [#{mres["end_timecode"]}]"
                   $stderr.puts line.error if @debug
                 end
@@ -50,7 +50,6 @@ module SRT
             else
               line.text << str.strip
             end
-
           end
         rescue
           line.error = "#{index}, General Error, [#{str}]"
@@ -76,8 +75,8 @@ module SRT
     end
 
     def append(options)
-      if options.length == 1 && options.values[0].class == SRT::File
-        reshift = SRT::File.parse_timecode(options.keys[0]) || (lines.last.end_time + SRT::File.parse_timespan(options.keys[0]))
+      if options.length == 1 && options.values[0].class == self.class
+        reshift = Parser.timecode(options.keys[0]) || (lines.last.end_time + Parser.timespan(options.keys[0]))
         renumber = lines.last.sequence
 
         options.values[0].lines.each do |line|
@@ -97,15 +96,15 @@ module SRT
       split_points = []
 
       if (options[:at])
-        split_points = [options[:at]].flatten.map{ |timecode| SRT::File.parse_timecode(timecode) }.sort
+        split_points = [options[:at]].flatten.map{ |timecode| Parser.timecode(timecode) }.sort
       elsif (options[:every])
-        interval = SRT::File.parse_timecode(options[:every])
+        interval = Parser.timecode(options[:every])
         max = lines.last.end_time
         (interval..max).step(interval){ |t| split_points << t }
       end
 
       if (split_points.count > 0)
-        split_offsprings = [SRT::File.new]
+        split_offsprings = [File.new]
 
         reshift = 0
         renumber = 0
@@ -132,7 +131,7 @@ module SRT
             reshift = split_points.first
             split_points.delete_at(0)
 
-            split_offsprings << SRT::File.new
+            split_offsprings << File.new
             cloned_line = line.clone
             cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
@@ -145,7 +144,7 @@ module SRT
             reshift = split_points.first
             split_points.delete_at(0)
 
-            split_offsprings << SRT::File.new
+            split_offsprings << File.new
             cloned_line = line.clone
             cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
@@ -162,12 +161,12 @@ module SRT
 
     def timeshift(options)
       if options.length == 1
-        if options[:all] && (seconds = SRT::File.parse_timespan(options[:all]))
+        if options[:all] && (seconds = Parser.timespan(options[:all]))
           lines.each do |line|
             line.start_time += seconds
             line.end_time += seconds
           end
-        elsif (original_framerate = SRT::File.parse_framerate(options.keys[0])) && (target_framerate = SRT::File.parse_framerate(options.values[0]))
+        elsif (original_framerate = Parser.framerate(options.keys[0])) && (target_framerate = Parser.framerate(options.values[0]))
           ratio = target_framerate / original_framerate
           lines.each do |line|
             line.start_time *= ratio
@@ -178,16 +177,16 @@ module SRT
         origins, targets = options.keys, options.values
 
         [0,1].each do |i|
-          if origins[i].is_a?(String) && SRT::File.parse_id(origins[i])
-            origins[i] = lines[SRT::File.parse_id(origins[i]) - 1].start_time
-          elsif origins[i].is_a?(String) && SRT::File.parse_timecode(origins[i])
-            origins[i] = SRT::File.parse_timecode(origins[i])
+          if origins[i].is_a?(String) && Parser.id(origins[i])
+            origins[i] = lines[Parser.id(origins[i]) - 1].start_time
+          elsif origins[i].is_a?(String) && Parser.timecode(origins[i])
+            origins[i] = Parser.timecode(origins[i])
           end
 
-          if targets[i].is_a?(String) && SRT::File.parse_timecode(targets[i])
-            targets[i] = SRT::File.parse_timecode(targets[i])
-          elsif targets[i].is_a?(String) && SRT::File.parse_timespan(targets[i])
-            targets[i] = origins[i] + SRT::File.parse_timespan(targets[i])
+          if targets[i].is_a?(String) && Parser.timecode(targets[i])
+            targets[i] = Parser.timecode(targets[i])
+          elsif targets[i].is_a?(String) && Parser.timespan(targets[i])
+            targets[i] = origins[i] + Parser.timespan(targets[i])
           end
         end
 
@@ -231,33 +230,5 @@ eos
     def errors
       lines.collect { |l| l.error if l.error }.compact
     end
-
-    protected
-
-    def self.parse_framerate(framerate_string)
-      mres = framerate_string.match(/(?<fps>\d+((\.)?\d+))(fps)/)
-      mres ? mres["fps"].to_f : nil
-    end
-
-    def self.parse_id(id_string)
-      mres = id_string.match(/#(?<id>\d+)/)
-      mres ? mres["id"].to_i : nil
-    end
-
-    def self.parse_timecode(timecode_string)
-      mres = timecode_string.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+),(?<ms>\d+)/)
-      mres ? "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["ms"]}".to_f : nil
-    end
-
-    def self.parse_timespan(timespan_string)
-      factors = {
-        "ms" => 0.001,
-        "s" => 1,
-        "m" => 60,
-        "h" => 3600
-      }
-      mres = timespan_string.match(/(?<amount>(\+|-)?\d+((\.)?\d+)?)(?<unit>ms|s|m|h)/)
-      mres ? mres["amount"].to_f * factors[mres["unit"]] : nil
-    end
   end
 end

data/lib/srt/parser.rb

@@ -0,0 +1,31 @@
+module SRT
+  class Parser
+    class << self
+      def framerate(framerate_string)
+        mres = framerate_string.match(/(?<fps>\d+((\.)?\d+))(fps)/)
+        mres ? mres["fps"].to_f : nil
+      end
+
+      def id(id_string)
+        mres = id_string.match(/#(?<id>\d+)/)
+          mres ? mres["id"].to_i : nil
+      end
+
+      def timecode(timecode_string)
+        mres = timecode_string.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+),(?<ms>\d+)/)
+        mres ? "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["ms"]}".to_f : nil
+      end
+
+      def timespan(timespan_string)
+        factors = {
+          "ms" => 0.001,
+          "s" => 1,
+          "m" => 60,
+          "h" => 3600
+        }
+        mres = timespan_string.match(/(?<amount>(\+|-)?\d+((\.)?\d+)?)(?<unit>ms|s|m|h)/)
+        mres ? mres["amount"].to_f * factors[mres["unit"]] : nil
+      end
+    end
+  end
+end

data/lib/srt/version.rb

@@ -1,3 +1,3 @@
 module SRT
-  VERSION = "0.0.10"
+  VERSION = "0.1.0"
 end

data/spec/file_spec.rb

@@ -0,0 +1,440 @@
+require 'spec_helper'
+require 'srt'
+
+describe SRT::File do
+  describe '#parse' do
+    context "parsing with debug true" do
+      it "should be verbose when failing" do
+        $stderr.should_receive(:puts).once
+        SRT::File.parse(File.open("./spec/fixtures/invalid.srt"), debug: true).errors.should_not be_empty
+      end
+    end
+    context "parsing with debug false" do
+      it "should raise exception silently" do
+        $stderr.should_not_receive(:puts)
+        SRT::File.parse(File.open("./spec/fixtures/invalid.srt")).errors.should_not be_empty
+      end
+    end
+  end
+
+  shared_examples_for "an SRT file" do
+    context "when parsing a properly formatted BSG SRT file" do
+      it "should return an SRT::File" do
+        subject.class.should eq(SRT::File)
+      end
+
+      it "should have 600 lines" do
+        subject.lines.size.should eq(600)
+      end
+
+      it "should have no errors" do
+        subject.errors.should be_empty
+      end
+
+      it "should have the expected sequence number on the first subtitle" do
+        subject.lines.first.sequence.should eq(1)
+      end
+
+      it "should have the expected timecodes on the first subtitle" do
+        subject.lines.first.time_str.should eq("00:00:02,110 --> 00:00:04,578")
+      end
+
+      it "should have the expected text on the first subtitle" do
+        subject.lines.first.text.should eq(["<i>(male narrator) Previously", "on Battlestar Galactica.</i>"])
+      end
+
+      it "should have the expected sequence number on the last subtitle" do
+        subject.lines.last.sequence.should eq(600)
+      end
+
+      it "should have the expected timecodes on the last subtitle" do
+        subject.lines.last.time_str.should eq("00:43:26,808 --> 00:43:28,139")
+      end
+
+      it "should have the expected text on the last subtitle" do
+        subject.lines.last.text.should eq(["Thank you."])
+      end
+    end
+  end
+
+  describe ".parse with uncommon formats" do
+    context "when parsing a spanish language WOTW SRT file with unknown encoding" do
+      let(:file) { SRT::File.parse(File.open("./spec/fixtures/wotw-dubious.srt")) }
+
+      it "should parse" do
+        file.class.should eq(SRT::File)
+      end
+
+      it "should have 1123 lines" do
+        file.lines.size.should eq(1123)
+      end
+
+      it "should have no errors" do
+        file.errors.should be_empty
+      end
+    end
+
+    context "when parsing a dummy SRT file containing display coordinates" do
+      let(:file) { SRT::File.parse(File.open("./spec/fixtures/coordinates-dummy.srt")) }
+
+      it "should return an SRT::File" do
+        file.class.should eq(SRT::File)
+      end
+
+      it "should have 3 lines" do
+        file.lines.size.should eq(3)
+      end
+
+      it "should have no errors" do
+        file.errors.should be_empty
+      end
+
+      it "should have the expected display coordinates on the first subtitle" do
+        file.lines.first.display_coordinates.should eq("X1:100 X2:600 Y1:1 Y2:4")
+      end
+
+      it "should have the expected display coordinates on the last subtitle" do
+        file.lines.last.display_coordinates.should eq("X1:1 X2:333 Y1:50 Y2:29")
+      end
+    end
+  end
+
+  describe SRT::File, "when initialized with a valid BSG SRT string" do
+    subject { SRT::File.parse(File.read("./spec/fixtures/bsg-s01e01.srt")) }
+    it_should_behave_like "an SRT file"
+  end
+
+  describe SRT::File, "when initialized with a valid BSG SRT File" do
+    subject { SRT::File.parse(File.open("./spec/fixtures/bsg-s01e01.srt")) }
+    it_should_behave_like "an SRT file"
+  end
+
+  describe "#append" do
+    context "when calling it on the first (part1) of two seperate SRT files for Black Swan" do
+      let(:part1) { SRT::File.parse(File.open("./spec/fixtures/blackswan-part1.srt")) }
+      let(:part2) { SRT::File.parse(File.open("./spec/fixtures/blackswan-part2.srt")) }
+
+      context "when passing { \"00:53:57,241\" => part2 }" do
+        before { part1.append({ "00:53:57,241" => part2 }) }
+
+        it "should have grown to 808 subtitles" do
+          part1.lines.length.should eq(808)
+        end
+
+        it "should have appended subtitles starting with sequence number 448" do
+          part1.lines[447].sequence.should eq(448)
+        end
+
+        it "should have appended subtitles ending with sequence number 808" do
+          part1.lines.last.sequence.should eq(808)
+        end
+
+        it "should have appended subtitles relatively from 00:53:57,241" do
+          part1.lines[447].time_str.should eq("00:54:02,152 --> 00:54:04,204")
+        end
+      end
+
+      context "when passing { \"+7.241s\" => part2 }" do
+        before { part1.append({ "+7.241s" => part2 }) }
+
+        it "should have appended subtitles relatively from +7.241s after the previously last subtitle" do
+          part1.lines[447].time_str.should eq("00:54:02,283 --> 00:54:04,335")
+        end
+      end
+    end
+  end
+
+  describe "#split" do
+    context "when calling it on a properly formatted BSG SRT file" do
+      let(:file) { SRT::File.parse(File.open("./spec/fixtures/bsg-s01e01.srt")) }
+
+      context "when passing { :at => \"00:19:24,500\" }" do
+        let(:result) { file.split( :at => "00:19:24,500" ) }
+
+        it "should return an array containing two SRT::File instances" do
+          result.length.should eq(2)
+          result[0].class.should eq(SRT::File)
+          result[1].class.should eq(SRT::File)
+        end
+
+        it "should include a subtitle that overlaps a splitting point in the first file" do
+          result[0].lines.last.text.should eq(["I'll see you guys in combat."])
+        end
+
+        it "should make an overlapping subtitle end at the splitting point in the first file" do
+          result[0].lines.last.time_str.should eq("00:19:23,901 --> 00:19:24,500")
+        end
+
+        it "should include a subtitle that overlaps a splitting point in the second file as well" do
+          result[1].lines.first.text.should eq(["I'll see you guys in combat."])
+        end
+
+        it "should make an overlapping subtitle remain at the beginning in the second file" do
+          result[1].lines.first.time_str.should eq("00:00:00,000 --> 00:00:01,528")
+        end
+
+        it "should shift back all timecodes of the second file relative to the new file beginning" do
+          result[1].lines[1].time_str.should eq("00:00:01,737 --> 00:00:03,466")
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :timeshift => false }" do
+        let(:result) { file.split( :at => "00:19:24,500", :timeshift => false ) }
+
+        it "should return an array containing two SRT::File instances" do
+          result.length.should eq(2)
+          result[0].class.should eq(SRT::File)
+          result[1].class.should eq(SRT::File)
+        end
+
+        it "should include a subtitle that overlaps a splitting point in the first file" do
+          result[0].lines.last.text.should eq(["I'll see you guys in combat."])
+        end
+
+        it "should not make an overlapping subtitle end at the splitting point in the first file" do
+          result[0].lines.last.time_str.should eq("00:19:23,901 --> 00:19:26,028")
+        end
+
+        it "should include a subtitle that overlaps a splitting point in the second file as well" do
+          result[1].lines.first.text.should eq(["I'll see you guys in combat."])
+        end
+
+        it "should not make an overlapping subtitle remain at the beginning in the second file" do
+          result[1].lines.first.time_str.should eq("00:19:23,901 --> 00:19:26,028")
+        end
+
+        it "should not shift back timecodes of the second file relative to the new file beginning" do
+          result[1].lines[1].time_str.should eq("00:19:26,237 --> 00:19:27,966")
+        end
+      end
+
+      context "when passing { :at => [\"00:15:00,000\", \"00:30:00,000\"] }" do
+        let(:result) { file.split( :at => ["00:15:00,000", "00:30:00,000"] ) }
+
+        it "should return an array containing three SRT::File instances" do
+          result.length.should eq(3)
+          result[0].class.should eq(SRT::File)
+          result[1].class.should eq(SRT::File)
+          result[2].class.should eq(SRT::File)
+        end
+
+        it "should let subtitles start at sequence number #1 in all three files" do
+          result[0].lines.first.sequence.should eq(1)
+          result[1].lines.first.sequence.should eq(1)
+          result[2].lines.first.sequence.should eq(1)
+        end
+
+        it "should put 176 subtitles in the first file" do
+          result[0].lines.length.should eq(176)
+          result[0].lines.last.sequence.should eq(176)
+        end
+
+        it "should put 213 subtitles in the second file" do
+          result[1].lines.length.should eq(213)
+          result[1].lines.last.sequence.should eq(213)
+        end
+
+        it "should put 212 subtitles in the third file" do
+          result[2].lines.length.should eq(212)
+          result[2].lines.last.sequence.should eq(212)
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :every => \"00:00:01,000\" }" do
+        let(:result) { file.split( :at => "00:19:24,500", :every => "00:00:01,000" ) }
+
+        it "should return an array containing two SRT::File instances, ignoring :every" do
+          result.length.should eq(2)
+          result[0].class.should eq(SRT::File)
+          result[1].class.should eq(SRT::File)
+        end
+      end
+
+      context "when passing { :every => \"00:05:00,000\" }" do
+        let(:result) { file.split( :every => "00:05:00,000" ) }
+
+        it "should return an array containing nine SRT::File instances" do
+          result.length.should eq(9)
+          (0...result.count).each do |n|
+            result[n].class.should eq(SRT::File)
+          end
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :renumber => false }" do
+        let(:result) { file.split( :at => "00:19:24,500", :renumber => false ) }
+
+        it "sequence for the last line of first part should be the sequence for the first line of second part" do
+          result[0].lines.last.text.should == result[1].lines.first.text
+          result[0].lines.last.sequence.should == result[1].lines.first.sequence
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :renumber => true }" do
+        let(:result) { file.split( :at => "00:19:24,500", :renumber => true ) }
+
+        it "first line of second part's number should be one" do
+          result[1].lines.first.sequence.should == 1
+        end
+
+        it "sequence for the last line of first part should have different number than the sequence for the first line of second part" do
+          result[0].lines.last.text.should == result[1].lines.first.text
+          result[0].lines.last.sequence.should_not == result[1].lines.first.sequence
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :timeshift => false }" do
+        let(:result) { file.split( :at => "00:19:24,500", :timeshift => false ) }
+
+        it "time for last line of first part should be the time for first line of second part" do
+          result[0].lines.last.text.should == result[1].lines.first.text
+          result[0].lines.last.time_str.should == result[1].lines.first.time_str
+        end
+      end
+
+      context "when passing { :at => \"00:19:24,500\", :timeshift => true }" do
+        let(:result) { file.split( :at => "00:19:24,500", :timeshift => true ) }
+
+        it "start_time of first line in second part should be 0" do
+          result[1].lines.first.start_time.should == 0
+        end
+
+        it "time for last line of first part should not be the time for first line of second part" do
+          result[0].lines.last.text.should == result[1].lines.first.text
+          result[0].lines.last.time_str.should_not == result[1].lines.first.time_str
+        end
+      end
+    end
+  end
+
+  describe "#timeshift" do
+    context "when calling it on a properly formatted BSG SRT file" do
+      let(:file) { SRT::File.parse(File.open("./spec/fixtures/bsg-s01e01.srt")) }
+
+      context "when passing { :all => \"+2.5s\" }" do
+        before { file.timeshift({ :all => "+2.5s" }) }
+
+        it "should have timecodes shifted forward by 2.5s for subtitle #24" do
+          file.lines[23].time_str.should eq("00:01:59,291 --> 00:02:00,815")
+        end
+
+        it "should have timecodes shifted forward by 2.5s for subtitle #43" do
+          file.lines[42].time_str.should eq("00:03:46,164 --> 00:03:47,631")
+        end
+      end
+
+      context "when passing { \"25fps\" => \"23.976fps\" }" do
+        before { file.timeshift({ "25fps" => "23.976fps" }) }
+
+        it "should have correctly scaled timecodes for subtitle #24" do
+          file.lines[23].time_str.should eq("00:01:52,007 --> 00:01:53,469")
+        end
+
+        it "should have correctly scaled timecodes for subtitle #43" do
+          file.lines[42].time_str.should eq("00:03:34,503 --> 00:03:35,910")
+        end
+      end
+
+      context "when passing { \"#24\" => \"00:03:53,582\", \"#42\" => \"00:04:24,656\" }" do
+        before { file.timeshift({ "#24" => "00:03:53,582", "#42" => "00:04:24,656" }) }
+
+        it "should have shifted timecodes for subtitle #24" do
+          file.lines[23].time_str.should eq("00:03:53,582 --> 00:03:54,042")
+        end
+
+        it "should have differently shifted timecodes for subtitle #43" do
+          file.lines[41].time_str.should eq("00:04:24,656 --> 00:04:25,298")
+        end
+      end
+
+      context "when passing { 180 => \"+1s\", 264 => \"+1.5s\" }" do
+        before { file.timeshift({ 180 => "+1s", 264 => "+1.5s" }) }
+
+        it "should have shifted by +1s at 180 seconds" do
+          file.lines[23].time_str.should eq("00:01:57,415 --> 00:01:58,948")
+        end
+
+        it "should have shifted by +1.5s at 264 seconds" do
+          file.lines[41].time_str.should eq("00:03:40,997 --> 00:03:43,136")
+        end
+      end
+    end
+
+    context "when calling it on a spanish language WOTW SRT file with unknown encoding" do
+      let(:file) { SRT::File.parse(File.open("./spec/fixtures/wotw-dubious.srt")) }
+
+      context "when passing { :all => \"-2.7m\" }" do
+        before { file.timeshift({ :all => "-2.7m" }) }
+
+        it "should have dumped 16 lines with now negative timecodes, leaving 1107" do
+          file.lines.size.should eq(1107)
+        end
+      end
+
+      context "when passing { \"00:03:25,430\" => \"00:00:44,200\", \"01:49:29,980\" => \"01:46:35,600\" }" do
+        before { file.timeshift({ "00:03:25,430" => "00:00:44,200", "01:49:29,980" => "01:46:35,600" }) }
+
+        it "should have dumped 16 lines with now negative timecodes, leaving 1107" do
+          file.lines.size.should eq(1107)
+        end
+      end
+    end
+
+    describe "#to_s" do
+      context "when calling it on a short SRT file" do
+        let(:file) { SRT::File.parse(File.open("./spec/fixtures/bsg-s01e01.srt")) }
+
+        before { file.lines = file.lines[0..2] }
+
+        it "should produce the exactly correct output" do
+          OUTPUT =<<END
+1
+00:00:02,110 --> 00:00:04,578
+<i>(male narrator) Previously
+on Battlestar Galactica.</i>
+
+2
+00:00:05,313 --> 00:00:06,871
+Now you're telling me
+you're a machine.
+
+3
+00:00:07,014 --> 00:00:08,003
+The robot.
+END
+          file.to_s.should eq(OUTPUT)
+        end
+      end
+    end
+
+    describe "#to_webvtt" do
+      context "when calling it on a short SRT file" do
+        let(:file) { SRT::File.parse(File.open("./spec/fixtures/bsg-s01e01.srt")) }
+
+        before { file.lines = file.lines[0..2] }
+
+        it "should produce the exactly correct output" do
+          OUTPUT_WEBVTT =<<END
+WEBVTT
+X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
+
+1
+00:00:02.110 --> 00:00:04.578
+<i>(male narrator) Previously
+on Battlestar Galactica.</i>
+
+2
+00:00:05.313 --> 00:00:06.871
+Now you're telling me
+you're a machine.
+
+3
+00:00:07.014 --> 00:00:08.003
+The robot.
+END
+          file.to_webvtt.should eq(OUTPUT_WEBVTT)
+        end
+      end
+    end
+  end
+end