srt 0.1.0 → 0.1.5

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Mzk5Mjk2ZGU5NjI2NTZjYWVmN2JkN2E1MTY4ZjJkMmEzZmRmNzA5ZA==
-  data.tar.gz: !binary |-
-    MTIxY2EyYTczM2Q2NTg1NjZlZGNlNDQ4ZGQ4MDRmZDBmOWE3OTA1Yg==
+SHA256:
+  metadata.gz: 28e7323497b349d7a2089aa395ad2c1ba1c3985729111dc56706c3280521bb5f
+  data.tar.gz: 82fe89057aee1e6a6aea48a16d33740686a18d0444f5559820603ff1b9a2a062
 SHA512:
-  metadata.gz: !binary |-
-    MTQyM2M1Y2I4ZDY5MGJkNTk3MWVkNGJkNzk5ZWI5MTJkYjZkMjBiYzhmMDY0
-    YThlZDQyOWQ5YzRmYjNjODkwYjFmMGM4ZjQ1ZTgwN2QwMTJiOWM3Y2I0Y2M1
-    Njc4NTg5ZjI5ZTNiZTAxZjYzYzQzZjg2YmFjODY5NzUyOTVjOTE=
-  data.tar.gz: !binary |-
-    NzIyNzExYzBiMjYzZWMzOGVkZDMyZjhiN2EyNWNmNGZhNThhNzkwMDhmNGRk
-    NGE3ZTMxMjA5YmNlYjJmYmNmZmZmYTgwNDIzOWJkZjA2YzE2YzAyZThlOGY5
-    ZTNhYTBlN2ZiYmFlYmY2ZmM4NzI0ODc5NTg4MmFmNDY5YjE1NTE=
+  metadata.gz: 699aaea2dda022acb10cb2e5d1db24d36ad8adec53528b1e186c6b75a549a049cbfd33f806d2cd4e276ae7ecabde412c9e9181c50335dc2f613ac79cefda5f31
+  data.tar.gz: c8abffc1bf997c624ee0cb0e06b0a49b9dd88b584a6fdb3c9edbd3170acb3a5e8a449b4d35eb3edfd2bc825c79389170da2d44589be602b02dced7a39223e4ef

data/.travis.yml

@@ -1,2 +1,8 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.3.0
 script:
-  - bundle exec rake spec
+  - bundle exec rake spec

data/lib/srt/file.rb

@@ -67,6 +67,7 @@ module SRT
         srt_data.split(/\n/) + ["\n"]
       rescue
         begin
+          srt_data = srt_data.unpack("C*").pack("U*")
           srt_data.force_encoding('utf-8').split(/\n/) + ["\n"]
         rescue
           srt_data.force_encoding('iso-8859-1').split(/\n/) + ["\n"]
@@ -167,10 +168,10 @@ module SRT
             line.end_time += seconds
           end
         elsif (original_framerate = Parser.framerate(options.keys[0])) && (target_framerate = Parser.framerate(options.values[0]))
-          ratio = target_framerate / original_framerate
+          time_ratio = original_framerate / target_framerate
           lines.each do |line|
-            line.start_time *= ratio
-            line.end_time *= ratio
+            line.start_time *= time_ratio
+            line.end_time *= time_ratio
           end
         end
       elsif options.length == 2
@@ -209,13 +210,13 @@ module SRT
     end
 
     def to_s(time_str_function=:time_str)
-      lines.map { |l| [l.sequence, (l.display_coordinates ? l.send(time_str_function) + l.display_coordinates : l.send(time_str_function)), l.text, ""] }.flatten.join("\n")
+      lines.map { |l| l.to_s(time_str_function) }.join("\n")
     end
 
     def to_webvtt
       header = <<eos
 WEBVTT
-X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
+X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000
 
 eos
       header + to_s(:webvtt_time_str)

data/lib/srt/line.rb

@@ -33,11 +33,17 @@ module SRT
     end
 
     def time_str(subframe_separator=",")
-      [@start_time, @end_time].map { |t| sprintf("%02d:%02d:%02d#{subframe_separator}%s", t / 3600, (t % 3600) / 60, t % 60, sprintf("%.3f", t)[-3, 3]) }.join(" --> ")
+      [@start_time, @end_time].map { |t|  f=sprintf("%.3f", t); ip=f[0,f.size-4].to_i;fp=f[-3,3]; "%02d:%02d:%02d#{subframe_separator}%s" % [ip / 3600, (ip % 3600) / 60, ip % 60,fp] }.join(" --> ")
     end
 
     def webvtt_time_str
       time_str(".")
     end
+
+    def to_s(time_str_function=:time_str)
+      content = text.empty? ? [''] : text
+      coordinates = display_coordinates ? display_coordinates : ""
+      [sequence, send(time_str_function) + coordinates, content, ""].flatten.join("\n")
+    end
   end
 end

data/lib/srt/parser.rb

@@ -12,7 +12,7 @@ module SRT
       end
 
       def timecode(timecode_string)
-        mres = timecode_string.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+),(?<ms>\d+)/)
+        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
 

data/lib/srt/version.rb

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

data/spec/file_spec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'spec_helper'
 require 'srt'
 
@@ -5,14 +6,14 @@ 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
+        expect($stderr).to receive(:puts).once
+        expect(SRT::File.parse(File.open("./spec/fixtures/invalid.srt"), debug: true).errors).not_to 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
+        expect($stderr).not_to receive(:puts)
+        expect(SRT::File.parse(File.open("./spec/fixtures/invalid.srt")).errors).not_to be_empty
       end
     end
   end
@@ -20,39 +21,39 @@ describe SRT::File do
   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)
+        expect(subject.class).to eq(SRT::File)
       end
 
       it "should have 600 lines" do
-        subject.lines.size.should eq(600)
+        expect(subject.lines.size).to eq(600)
       end
 
       it "should have no errors" do
-        subject.errors.should be_empty
+        expect(subject.errors).to be_empty
       end
 
       it "should have the expected sequence number on the first subtitle" do
-        subject.lines.first.sequence.should eq(1)
+        expect(subject.lines.first.sequence).to 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")
+        expect(subject.lines.first.time_str).to 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>"])
+        expect(subject.lines.first.text).to 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)
+        expect(subject.lines.last.sequence).to 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")
+        expect(subject.lines.last.time_str).to 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."])
+        expect(subject.lines.last.text).to eq(["Thank you."])
       end
     end
   end
@@ -62,15 +63,20 @@ describe SRT::File do
       let(:file) { SRT::File.parse(File.open("./spec/fixtures/wotw-dubious.srt")) }
 
       it "should parse" do
-        file.class.should eq(SRT::File)
+        expect(file.class).to eq(SRT::File)
       end
 
       it "should have 1123 lines" do
-        file.lines.size.should eq(1123)
+        expect(file.lines.size).to eq(1123)
       end
 
       it "should have no errors" do
-        file.errors.should be_empty
+        expect(file.errors).to be_empty
+      end
+
+      it "should convert some dubious UTF-8 encodings" do
+        first_line = file.lines.first.text.join(" ")
+        expect(first_line).to eq("<i>Nadie habría creído en los primeros años del siglo 21...</i>")
       end
     end
 
@@ -78,23 +84,23 @@ describe SRT::File 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)
+        expect(file.class).to eq(SRT::File)
       end
 
       it "should have 3 lines" do
-        file.lines.size.should eq(3)
+        expect(file.lines.size).to eq(3)
       end
 
       it "should have no errors" do
-        file.errors.should be_empty
+        expect(file.errors).to 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")
+        expect(file.lines.first.display_coordinates).to 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")
+        expect(file.lines.last.display_coordinates).to eq("X1:1 X2:333 Y1:50 Y2:29")
       end
     end
   end
@@ -118,19 +124,19 @@ describe SRT::File do
         before { part1.append({ "00:53:57,241" => part2 }) }
 
         it "should have grown to 808 subtitles" do
-          part1.lines.length.should eq(808)
+          expect(part1.lines.length).to eq(808)
         end
 
         it "should have appended subtitles starting with sequence number 448" do
-          part1.lines[447].sequence.should eq(448)
+          expect(part1.lines[447].sequence).to eq(448)
         end
 
         it "should have appended subtitles ending with sequence number 808" do
-          part1.lines.last.sequence.should eq(808)
+          expect(part1.lines.last.sequence).to 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")
+          expect(part1.lines[447].time_str).to eq("00:54:02,152 --> 00:54:04,204")
         end
       end
 
@@ -138,7 +144,7 @@ describe SRT::File 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")
+          expect(part1.lines[447].time_str).to eq("00:54:02,283 --> 00:54:04,335")
         end
       end
     end
@@ -152,29 +158,29 @@ describe SRT::File 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)
+          expect(result.length).to eq(2)
+          expect(result[0].class).to eq(SRT::File)
+          expect(result[1].class).to 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."])
+          expect(result[0].lines.last.text).to 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")
+          expect(result[0].lines.last.time_str).to 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."])
+          expect(result[1].lines.first.text).to 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")
+          expect(result[1].lines.first.time_str).to 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")
+          expect(result[1].lines[1].time_str).to eq("00:00:01,737 --> 00:00:03,466")
         end
       end
 
@@ -182,29 +188,29 @@ describe SRT::File 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)
+          expect(result.length).to eq(2)
+          expect(result[0].class).to eq(SRT::File)
+          expect(result[1].class).to 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."])
+          expect(result[0].lines.last.text).to 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")
+          expect(result[0].lines.last.time_str).to 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."])
+          expect(result[1].lines.first.text).to 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")
+          expect(result[1].lines.first.time_str).to 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")
+          expect(result[1].lines[1].time_str).to eq("00:19:26,237 --> 00:19:27,966")
         end
       end
 
@@ -212,31 +218,31 @@ describe SRT::File 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)
+          expect(result.length).to eq(3)
+          expect(result[0].class).to eq(SRT::File)
+          expect(result[1].class).to eq(SRT::File)
+          expect(result[2].class).to 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)
+          expect(result[0].lines.first.sequence).to eq(1)
+          expect(result[1].lines.first.sequence).to eq(1)
+          expect(result[2].lines.first.sequence).to 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)
+          expect(result[0].lines.length).to eq(176)
+          expect(result[0].lines.last.sequence).to 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)
+          expect(result[1].lines.length).to eq(213)
+          expect(result[1].lines.last.sequence).to 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)
+          expect(result[2].lines.length).to eq(212)
+          expect(result[2].lines.last.sequence).to eq(212)
         end
       end
 
@@ -244,9 +250,9 @@ describe SRT::File 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)
+          expect(result.length).to eq(2)
+          expect(result[0].class).to eq(SRT::File)
+          expect(result[1].class).to eq(SRT::File)
         end
       end
 
@@ -254,9 +260,9 @@ describe SRT::File 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)
+          expect(result.length).to eq(9)
           (0...result.count).each do |n|
-            result[n].class.should eq(SRT::File)
+            expect(result[n].class).to eq(SRT::File)
           end
         end
       end
@@ -265,8 +271,8 @@ describe SRT::File 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
+          expect(result[0].lines.last.text).to eq(result[1].lines.first.text)
+          expect(result[0].lines.last.sequence).to eq(result[1].lines.first.sequence)
         end
       end
 
@@ -274,12 +280,12 @@ describe SRT::File 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
+          expect(result[1].lines.first.sequence).to eq(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
+          expect(result[0].lines.last.text).to eq(result[1].lines.first.text)
+          expect(result[0].lines.last.sequence).not_to eq(result[1].lines.first.sequence)
         end
       end
 
@@ -287,8 +293,8 @@ describe SRT::File 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
+          expect(result[0].lines.last.text).to eq(result[1].lines.first.text)
+          expect(result[0].lines.last.time_str).to eq(result[1].lines.first.time_str)
         end
       end
 
@@ -296,12 +302,12 @@ describe SRT::File 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
+          expect(result[1].lines.first.start_time).to eq(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
+          expect(result[0].lines.last.text).to eq(result[1].lines.first.text)
+          expect(result[0].lines.last.time_str).not_to eq(result[1].lines.first.time_str)
         end
       end
     end
@@ -315,11 +321,11 @@ describe SRT::File 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")
+          expect(file.lines[23].time_str).to 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")
+          expect(file.lines[42].time_str).to eq("00:03:46,164 --> 00:03:47,631")
         end
       end
 
@@ -327,11 +333,11 @@ describe SRT::File 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")
+          expect(file.lines[23].time_str).to eq("00:02:01,779 --> 00:02:03,368")
         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")
+          expect(file.lines[42].time_str).to eq("00:03:53,217 --> 00:03:54,746")
         end
       end
 
@@ -339,11 +345,11 @@ describe SRT::File 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")
+          expect(file.lines[23].time_str).to 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")
+          expect(file.lines[41].time_str).to eq("00:04:24,656 --> 00:04:25,298")
         end
       end
 
@@ -351,11 +357,11 @@ describe SRT::File 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")
+          expect(file.lines[23].time_str).to 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")
+          expect(file.lines[41].time_str).to eq("00:03:40,997 --> 00:03:43,136")
         end
       end
     end
@@ -367,7 +373,7 @@ describe SRT::File 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)
+          expect(file.lines.size).to eq(1107)
         end
       end
 
@@ -375,7 +381,7 @@ describe SRT::File 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)
+          expect(file.lines.size).to eq(1107)
         end
       end
     end
@@ -402,7 +408,7 @@ you're a machine.
 00:00:07,014 --> 00:00:08,003
 The robot.
 END
-          file.to_s.should eq(OUTPUT)
+          expect(file.to_s).to eq(OUTPUT)
         end
       end
     end
@@ -416,7 +422,7 @@ END
         it "should produce the exactly correct output" do
           OUTPUT_WEBVTT =<<END
 WEBVTT
-X-TIMESTAMP-MAP=MPEGTS:0,LOCAL:00:00:00.000
+X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000
 
 1
 00:00:02.110 --> 00:00:04.578
@@ -432,7 +438,7 @@ you're a machine.
 00:00:07.014 --> 00:00:08.003
 The robot.
 END
-          file.to_webvtt.should eq(OUTPUT_WEBVTT)
+          expect(file.to_webvtt).to eq(OUTPUT_WEBVTT)
         end
       end
     end

data/spec/line_spec.rb

@@ -6,7 +6,7 @@ describe SRT::Line do
     let(:line) { SRT::Line.new }
 
     it "should create an empty subtitle" do
-      line.should be_empty
+      expect(line).to be_empty
     end
   end
 
@@ -19,7 +19,36 @@ describe SRT::Line do
     end
 
     it "should produce timecodes that match the internal float values" do
-      line.time_str.should eq("00:03:44,200 --> 00:04:04,578")
+      expect(line.time_str).to eq("00:03:44,200 --> 00:04:04,578")
+    end
+  end
+
+  describe "#time_str (second time)" do
+    let(:line) { SRT::Line.new }
+
+    before do
+      line.start_time = 36915.85455630479
+      line.end_time = 36915.999869858395
+    end
+
+    it "should produce timecodes that match the internal float values" do
+      expect(line.time_str).to eq("10:15:15,855 --> 10:15:16,000")
+    end
+  end
+
+  describe "#to_s" do
+    let(:line) { SRT::Line.new }
+
+    before do
+      line.sequence = "1"
+      line.start_time = 224.2
+      line.end_time = 244.578
+    end
+
+    context "with empty content" do
+      it "creates a valid empty node" do
+        expect(line.to_s).to eq("1\n00:03:44,200 --> 00:04:04,578\n\n")
+      end
     end
   end
 end

data/spec/parser_spec.rb

@@ -6,33 +6,37 @@ describe SRT::Parser do
 
   describe ".id" do
     it "should convert the id string (#[id]) to an int representing the sequence number" do
-      subject.id("#317").should eq(317)
+      expect(subject.id("#317")).to eq(317)
     end
   end
 
   describe ".timecode" do
     it "should convert the SRT timecode format to a float representing seconds" do
-      subject.timecode("01:03:44,200").should eq(3824.2)
+      expect(subject.timecode("01:03:44,200")).to eq(3824.2)
+    end
+
+    it "should handle timecodes with no milliseconds component" do
+      expect(subject.timecode("01:03:44")).to eq(3824.0)
     end
   end
 
   describe ".timespan" do
     it "should convert a timespan string ([+|-][amount][h|m|s|ms]) to a float representing seconds" do
-      subject.timespan("-3.5m").should eq(-210)
+      expect(subject.timespan("-3.5m")).to eq(-210)
     end
 
     it "should convert a timespan string ([+|-][amount][h|m|s|ms]) to a float representing seconds" do
-      subject.timespan("-1s").should eq(-1)
+      expect(subject.timespan("-1s")).to eq(-1)
     end
 
     it "should convert a timespan string ([+|-][amount][h|m|s|ms]) to a float representing seconds" do
-      subject.timespan("100ms").should eq(0.1)
+      expect(subject.timespan("100ms")).to eq(0.1)
     end
   end
 
   describe ".parse_framerate" do
     it "should convert a framerate string ([number]fps) to a float representing seconds" do
-      subject.framerate("23.976fps").should eq(23.976)
+      expect(subject.framerate("23.976fps")).to eq(23.976)
     end
   end
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: srt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Christopher Petersen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Ruby gem for parsing srt (subtitle) files. SRT stands for SubRip text
@@ -60,8 +60,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -92,17 +92,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Ruby gem for parsing subtitle files.