voot 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f0b1b7d1b82d3b452c84daabe479a407bd86e14
-  data.tar.gz: c89d119e5d1365d2943e597311c567b44f063f82
+  metadata.gz: 4663014318069925f156ecc91d0375178add107a
+  data.tar.gz: d462fa6bf6fed6bcbd8b292a46b981c2255bbdb2
 SHA512:
-  metadata.gz: e784362950fbe7b40259284438202fffbb250297340e71ebd07ec978dc78f13ee5b22f74c6d4321dc3b398b6f764da59e8fe5b770f203231d70e4f930a5b8f71
-  data.tar.gz: 4e19b0731cb1d9507d6d3e322fdd07c7737ea6a099f71341a5e2e024563f6b0e9854ffa42f8ab60d8ab4e573e994a2f541c3ff853de856497fbce77bf2ef426a
+  metadata.gz: 473e633f0c06fd79742ae767d30170f0a4e6bda3ca9ba98c961ecd8b845f6634550e4f4164a42c553a5709658a3fc9ca663d91808056d2a39df0eff1bd02bfb1
+  data.tar.gz: d8e8f6032846b150ba72b99e2300acadc1ec3f24c4be8c0245726d0668165acab2251f1102c4d9f2412302abb15a9f2fca582241fa0604f53ca483283cc1a88c

data/Guardfile

@@ -5,7 +5,7 @@ guard 'bundler' do
   watch(/^.+\.gemspec/)
 end
 
-guard :rspec do
+guard :rspec, cli: "--fail-fast" do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }

data/README.md

@@ -4,6 +4,16 @@
 
 Voot lets you read and write WebVTT files with great ease.
 
+## Usage
+
+    > vtt = Voot.load("~/Movies/My Indian Films/manty-poothon.vtt")
+    => #<Voot::Vtt>
+    > vtt.cues.length
+    => 1
+    > vtt.cues.first.payload
+    => "You are those knights and whatever, let me marry Srivani or we will dance"
+
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/voot.rb

@@ -1,5 +1,17 @@
 require "voot/version"
 require "voot/vtt"
+require "voot/parser"
+require "voot/transform"
 
 module Voot
+  def self.load(path)
+    transform = Voot::Transform.new
+    parser = Voot::Parser.new
+    vtt_contents = File.read(path)
+    parse_tree = parser.parse(vtt_contents)
+
+    transform.apply(parse_tree).tap do |vtt|
+      vtt.path = path
+    end
+  end
 end

data/lib/voot/cue.rb

@@ -15,11 +15,9 @@ module Voot
     end
 
     def to_webvtt
-      if has_identifier?
-        "#{identifier}\n#{cue_timing.to_webvtt}\n#{payload}"
-      else
-        "#{cue_timing.to_webvtt}\n#{payload}"
-      end
+      output = ""
+      output << identifier << "\n" if has_identifier?
+      output << cue_timing.to_webvtt << "\n" << payload
     end
   end
 end

data/lib/voot/cue_list.rb

@@ -4,7 +4,13 @@ module Voot
   class CueList < Array
 
     def to_webvtt
-      map(&:to_webvtt).join("\n\n")
+      sorted_cues.map(&:to_webvtt).join("\n\n")
+    end
+
+    private
+
+    def sorted_cues
+      sort_by { |cue| cue.cue_timing.start_timestamp }
     end
   end
 end

data/lib/voot/cue_timing.rb

@@ -1,32 +1,20 @@
+require "voot/timestamp"
+
 module Voot
   class CueTiming
-    attr_reader :start_seconds, :end_seconds
+    attr_reader :start_timestamp, :stop_timestamp
 
-    def initialize(options = {})
-      @start_seconds = options.fetch(:start_seconds)
-      @end_seconds = options.fetch(:end_seconds)
+    def initialize(start_timestamp, stop_timestamp)
+      @start_timestamp = start_timestamp
+      @stop_timestamp = stop_timestamp
     end
 
     def to_webvtt
-      "#{format_timestamp(start_seconds)} --> #{format_timestamp(end_seconds)}"
-    end
-
-    private
-
-    def format_timestamp(seconds)
-      "#{format_minutes(seconds)}:#{format_seconds(seconds)}.#{format_subseconds(seconds)}"
-    end
-
-    def format_minutes(seconds)
-      (seconds.to_i / 60).to_s.rjust(2, "0")
-    end
-
-    def format_seconds(seconds)
-      (seconds.to_i % 60).to_s.rjust(2, "0")
+      start_timestamp.to_webvtt << " --> " << stop_timestamp.to_webvtt
     end
 
-    def format_subseconds(seconds)
-      ((seconds * 1000).round % 1000).to_s.rjust(3, "0")
+    def cover?(seconds)
+      seconds.between?(start_timestamp.seconds_since_origin, stop_timestamp.seconds_since_origin)
     end
   end
 end

data/lib/voot/parser.rb

@@ -0,0 +1,43 @@
+require "parslet"
+
+module Voot
+  class Parser < Parslet::Parser
+    rule(:line_break) { match("[\r\n]|\r\n") }
+    rule(:whitespace) { match("[\s\t]") }
+    rule(:section_separator) { line_break.repeat(2) }
+
+    rule(:header_string) { (line_break.absent? >> any).repeat }
+    rule(:header) { str("WEBVTT") >> whitespace.repeat >> header_string.as(:header) }
+
+    rule(:digit) { match("[0-9]") }
+    rule(:colon) { match("[:]") }
+    rule(:period) { match("[.]") }
+
+    rule(:hours) { digit.repeat(2).as(:hours) >> colon }
+    rule(:minutes) { digit.repeat(2, 2).as(:minutes) >> colon }
+    rule(:seconds) { digit.repeat(2, 2).as(:seconds) >> period }
+    rule(:subseconds) { digit.repeat(3, 3).as(:subseconds) }
+
+    rule(:timestamp_without_hours) { minutes >> seconds >> subseconds }
+    rule(:timestamp_with_hours) { hours >> minutes >> seconds >> subseconds }
+
+    rule(:timestamp) { timestamp_without_hours | timestamp_with_hours }
+
+    rule(:timing_delimiter) { str("-->") }
+    rule(:cue_timing) { timestamp.as(:start) >> whitespace.repeat(1) >> timing_delimiter >> whitespace.repeat(1) >> timestamp.as(:stop) }
+
+    rule(:cue_identifier) { (line_break.absent? >> timing_delimiter.absent? >> any).repeat.as(:identifier) }
+
+    rule(:cue_payload) { (section_separator.absent? >> any).repeat.as(:payload) }
+
+    rule(:cue_without_identifier) { cue_timing >> line_break >> cue_payload }
+    rule(:cue_with_identifier) { cue_identifier >> line_break >> cue_timing >> line_break >> cue_payload }
+
+    rule(:cue) { cue_without_identifier | cue_with_identifier }
+    rule(:cue_list) { (section_separator >> cue).repeat }
+
+    rule(:file_body) { header >> cue_list.as(:cues) >> line_break.repeat }
+
+    root(:file_body)
+  end
+end

data/lib/voot/timestamp.rb

@@ -0,0 +1,49 @@
+module Voot
+  class Timestamp
+    include Comparable
+
+    attr_reader :seconds_since_origin
+
+    def initialize(seconds_since_origin)
+      @seconds_since_origin = seconds_since_origin.to_f.round(3)
+    end
+
+    def <=>(other)
+      if other.is_a?(Numeric)
+        seconds_since_origin <=> other
+      else
+        seconds_since_origin <=> other.seconds_since_origin
+      end
+    end
+
+    def hours
+      seconds_since_origin.to_i / 3600
+    end
+
+    def minutes
+      seconds_without_hours.to_i / 60
+    end
+
+    def seconds
+      seconds_since_origin.to_i % 60
+    end
+
+    def milliseconds
+      milliseconds_since_origin.round % 1000
+    end
+
+    def to_webvtt
+      "%02d:%02d:%02d.%03d" % [hours, minutes, seconds, milliseconds]
+    end
+
+    private
+
+    def milliseconds_since_origin
+      seconds_since_origin * 1000
+    end
+
+    def seconds_without_hours
+      seconds_since_origin % 3600
+    end
+  end
+end

data/lib/voot/transform.rb

@@ -0,0 +1,35 @@
+require "parslet"
+
+module Voot
+  class Transform < Parslet::Transform
+    rule(:minutes => simple(:minutes), :seconds => simple(:seconds), :subseconds => simple(:subseconds)) do
+      Voot::Timestamp.new((minutes.to_i * 60) + seconds.to_i + (subseconds.to_i / 1000.0))
+    end
+
+    rule(:hours => simple(:hours), :minutes => simple(:minutes), :seconds => simple(:seconds), :subseconds => simple(:subseconds)) do
+      Voot::Timestamp.new((hours.to_i * 3600) + (minutes.to_i * 60) + seconds.to_i + (subseconds.to_i / 1000.0))
+    end
+
+    rule(:start => simple(:start_timestamp), :stop => simple(:stop_timestamp), :payload => simple(:payload)) do
+      cue_timing = Voot::CueTiming.new(start_timestamp, stop_timestamp)
+      Voot::Cue.new(cue_timing: cue_timing, payload: payload.to_s)
+    end
+
+    rule(:start => simple(:start_timestamp), :stop => simple(:stop_timestamp), :payload => simple(:payload), :identifier => simple(:identifier)) do
+      cue_timing = Voot::CueTiming.new(start_timestamp, stop_timestamp)
+      Voot::Cue.new(cue_timing: cue_timing, payload: payload.to_s, identifier: identifier.to_s)
+    end
+
+    rule(:header => sequence(:header), :cues => sequence(:cues)) do
+      vtt = Voot::Vtt.new
+      cues.each { |cue| vtt.cues << cue }
+      vtt
+    end
+
+    rule(:header => simple(:header), :cues => sequence(:cues)) do
+      vtt = Voot::Vtt.new(header: header)
+      cues.each { |cue| vtt.cues << cue }
+      vtt
+    end
+  end
+end

data/lib/voot/version.rb

@@ -1,3 +1,3 @@
 module Voot
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/voot/vtt.rb

@@ -2,11 +2,10 @@ require "voot/cue_list"
 
 module Voot
   class Vtt
-    attr_reader :path
-    attr_accessor :header
+    attr_accessor :header, :path
 
     def initialize(options = {})
-      @path = options.fetch(:path)
+      @path = options[:path]
       @header = options[:header]
     end
 

data/spec/lib/voot/cue_list_spec.rb

@@ -11,12 +11,36 @@ describe Voot::CueList do
     context "when the list has an item in it" do
       before { cue_list << create_cue("reasonably priced", 0, 0) }
 
-      its(:to_webvtt) { should == "00:00.000 --> 00:00.000\nreasonably priced" }
+      its(:to_webvtt) { should == "00:00:00.000 --> 00:00:00.000\nreasonably priced" }
 
       context "when the list has multiple items" do
         before { cue_list << create_cue("toiletries", 1, 1) }
 
-        its(:to_webvtt) { should include "00:01.000 --> 00:01.000\ntoiletries" }
+        its(:to_webvtt) { should include "00:00:01.000 --> 00:00:01.000\ntoiletries" }
+
+        it "separates cues with a double newline" do
+          cue_list.to_webvtt.should == <<-ALL_THE_CUES.strip
+00:00:00.000 --> 00:00:00.000
+reasonably priced
+
+00:00:01.000 --> 00:00:01.000
+toiletries
+          ALL_THE_CUES
+        end
+
+        it "orders the cues by start time" do
+          cue_list << create_cue("hair spray", 0.5, 1)
+          cue_list.to_webvtt.should == <<-ALL_THE_CUES.strip
+00:00:00.000 --> 00:00:00.000
+reasonably priced
+
+00:00:00.500 --> 00:00:01.000
+hair spray
+
+00:00:01.000 --> 00:00:01.000
+toiletries
+          ALL_THE_CUES
+        end
       end
     end
   end

data/spec/lib/voot/cue_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Voot::Cue do
   let(:identifier) { "taco massacre" }
   let(:payload) { "tasty" }
-  let(:cue_timing) { Voot::CueTiming.new(start_seconds: 0, end_seconds: 1) }
+  let(:cue_timing) { create_timing(0, 1) }
 
   subject(:cue) do
     Voot::Cue.new(
@@ -33,13 +33,13 @@ describe Voot::Cue do
 
   describe "#to_webvtt" do
     context "when the identifier is set" do
-      its(:to_webvtt) { should == "taco massacre\n00:00.000 --> 00:01.000\ntasty" }
+      its(:to_webvtt) { should == "taco massacre\n00:00:00.000 --> 00:00:01.000\ntasty" }
     end
 
     context "when the identifier is not set" do
       let(:identifier) { nil }
 
-      its(:to_webvtt) { should == "00:00.000 --> 00:01.000\ntasty" }
+      its(:to_webvtt) { should == "00:00:00.000 --> 00:00:01.000\ntasty" }
     end
   end
 end

data/spec/lib/voot/cue_timing_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
 describe Voot::CueTiming do
-  let(:start_seconds) { 1.0001 }
-  let(:end_seconds) { 65.0009 }
-
-  subject(:cue_timing) do
-    Voot::CueTiming.new(
-      start_seconds: start_seconds,
-      end_seconds: end_seconds
-    )
-  end
+  let(:start_timestamp) { Voot::Timestamp.new(1.0001) }
+  let(:stop_timestamp) { Voot::Timestamp.new(65.0009) }
+
+  subject(:cue_timing) { Voot::CueTiming.new(start_timestamp, stop_timestamp) }
 
-  its(:to_webvtt) { should == "00:01.000 --> 01:05.001" }
+  its(:to_webvtt) { should == "00:00:01.000 --> 00:01:05.001" }
+
+  describe "#cover?" do
+    it { should cover 1.000 }
+    it { should cover 65.001 }
+  end
 end

data/spec/lib/voot/parser_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Voot::Parser do
+  subject(:parser) { Voot::Parser.new }
+
+  it { should parse("WEBVTT") }
+  it { should parse("WEBVTT\n\n") }
+
+  describe "#header" do
+    specify { parser.header.should parse("WEBVTT").as(header: []) }
+    specify { parser.header.should parse("WEBVTT - goose hugs").as(header: "- goose hugs") }
+  end
+
+  describe "#subseconds" do
+    specify { parser.subseconds.should parse("164").as(subseconds: "164") }
+  end
+
+  describe "#seconds" do
+    specify { parser.seconds.should parse("66.").as(seconds: "66") }
+  end
+
+  describe "#minutes" do
+    specify { parser.minutes.should parse("01:").as(minutes: "01") }
+  end
+
+  describe "#hours" do
+    specify { parser.hours.should parse("13:").as(hours: "13") }
+    specify { parser.hours.should parse("9000:").as(hours: "9000") }
+  end
+
+  describe "#timestamp_without_hours" do
+    specify { parser.timestamp_without_hours.should parse("01:33.007").as(minutes: "01", seconds: "33", subseconds: "007") }
+  end
+
+  describe "#timestamp_with_hours" do
+    specify { parser.timestamp_with_hours.should parse("11:59:59.999").as(hours: "11", minutes: "59", seconds: "59", subseconds: "999") }
+  end
+
+  describe "#timestamp" do
+    specify { parser.timestamp.should parse("01:33.007").as(minutes: "01", seconds: "33", subseconds: "007") }
+    specify { parser.timestamp.should parse("11:59:59.999").as(hours: "11", minutes: "59", seconds: "59", subseconds: "999") }
+  end
+
+  describe "#timing_delimiter" do
+    specify { parser.timing_delimiter.should parse("-->") }
+  end
+
+  describe "#cue_timing" do
+    specify { parser.cue_timing.should parse("01:33.007 -->\t 11:59:59.999").as(start: anything, stop: anything) }
+  end
+
+  describe "#cue_identifier" do
+    specify { parser.cue_identifier.should_not parse("drugboats --> ahoy") }
+    specify { parser.cue_identifier.should_not parse("puppet\npals") }
+    specify { parser.cue_identifier.should parse("evil squid cult").as(identifier: "evil squid cult") }
+  end
+
+  describe "#cue_payload" do
+    specify { parser.cue_payload.should parse("once upon a dingus").as(payload: "once upon a dingus") }
+    specify { parser.cue_payload.should parse("there were\nan prancess").as(payload: "there were\nan prancess") }
+    specify { parser.cue_payload.should_not parse("whare is\n\nlazy prance") }
+  end
+
+  describe "#cue_without_identifier" do
+    specify { parser.cue_without_identifier.should parse("00:00.000 --> 00:30.000\nget to the choppa?").as(start: anything, stop: anything, payload: anything) }
+  end
+
+  describe "#cue_with_identifier" do
+    specify { parser.cue_with_identifier.should parse("777\n00:00.000 --> 00:30.000\njhonny paints the wall").as(identifier: anything, start: anything, stop: anything, payload: anything) }
+  end
+
+  describe "#cue" do
+    specify { parser.cue.should parse("the hablet\n00:00.000 --> 00:30.000\nwelcam ashire\nbalbo").as(identifier: anything, start: anything, stop: anything, payload: anything) }
+    specify { parser.cue.should parse("04:00.000 --> 55:30.000\n(tom belmadal sings)").as(start: anything, stop: anything, payload: anything) }
+  end
+
+  describe "#file_body" do
+    specify { parser.file_body.should parse("WEBVTT").as(header: [], cues: []) }
+    specify { parser.file_body.should parse("WEBVTT\n\n00:00.000 --> 00:00.000\nhi").as(header: [], cues: [anything]) }
+    specify { parser.file_body.should parse("WEBVTT\n\n00:00.000 --> 00:00.000\nlike\n\n00:01.000 --> 00:01.000\nwut").as(header: [], cues: [anything, anything]) }
+  end
+end

data/spec/lib/voot/timestamp_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Voot::Timestamp do
+  subject(:timestamp) { Voot::Timestamp.new(seconds) }
+
+  describe "#<=>" do
+    let(:seconds) { 1.1 }
+
+    context "when comparing against the number of seconds" do
+      it { should == seconds }
+    end
+
+    context "when comparing against another timestamp" do
+      let(:other) { double(:timestamp, seconds_since_origin: seconds) }
+
+      it { should == other }
+    end
+  end
+
+  describe "#seconds_since_origin" do
+    context "when the seconds can round up" do
+      let(:seconds) { 0.0005 }
+
+      it "rounds the seconds to the nearest millisecond" do
+        timestamp.seconds_since_origin.should == 0.001
+      end
+    end
+
+    context "when the seconds can round up" do
+      let(:seconds) { 0.0014 }
+
+      it "rounds the seconds to the nearest millisecond" do
+        timestamp.seconds_since_origin.should == 0.001
+      end
+    end
+  end
+
+  describe "#hours" do
+    let(:seconds) { 3600 }
+
+    it "returns the number of hours in the timestamp" do
+      timestamp.hours.should == 1
+    end
+  end
+
+  describe "#minutes" do
+    let(:seconds) { 120 }
+
+    it "returns the number of minutes in the timestamp" do
+      timestamp.minutes.should == 2
+    end
+  end
+
+  describe "#seconds" do
+    let(:seconds) { 3 }
+
+    it "returns the number of seconds in the timestamp" do
+      timestamp.seconds.should == 3
+    end
+  end
+
+  describe "#milliseconds" do
+    let(:seconds) { 0.004 }
+
+    it "returns the number of milliseconds in the timestamp" do
+      timestamp.milliseconds.should == 4
+    end
+
+    context "when milliseconds can round up" do
+      let(:seconds) { 0.0045 }
+
+      it "returns the rounded-up number of milliseconds in the timestamp" do
+        timestamp.milliseconds.should == 5
+      end
+    end
+
+    context "when milliseconds can round down" do
+      let(:seconds) { 0.0031 }
+
+      it "returns the rounded-down number of milliseconds in the timestamp" do
+        timestamp.milliseconds.should == 3
+      end
+    end
+  end
+
+  describe "#to_webvtt" do
+    let(:seconds) { 3723.004 }
+
+    its(:to_webvtt) { should == "01:02:03.004" }
+  end
+end

data/spec/lib/voot/transform_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+describe Voot::Transform do
+  let(:cue_timing) { create_timing(61.001, 3661.001) }
+  let(:parser) { Voot::Parser.new }
+
+  subject(:transformed) { Voot::Transform.new.apply(parsed_input) }
+
+  describe "#timestamp" do
+    let(:parsed_input) { parser.timestamp.parse(input_string) }
+
+    context "when the timestamp does not have hours" do
+      let(:input_string) { "01:01.001" }
+
+      it { should == 61.001 }
+    end
+
+    context "when the timestamp has hours" do
+      let(:input_string) { "01:01:01.001" }
+
+      it { should == 3661.001 }
+    end
+  end
+
+  describe "#cue_timing" do
+    let(:input_string) { cue_timing.to_webvtt }
+    let(:parsed_input) { parser.cue_timing.parse(input_string) }
+
+    it { should == {start: 61.001, stop: 3661.001} }
+  end
+
+  describe "#cue" do
+    let(:parsed_input) { parser.cue.parse(cue.to_webvtt) }
+
+    context "when there is an identifier" do
+      let(:cue) { Voot::Cue.new(cue_timing: cue_timing, identifier: "ferdo", payload: "hes also too an habblet") }
+
+      its(:identifier) { should == "ferdo" }
+      its(:payload) { should == "hes also too an habblet" }
+      its(:cue_timing) { should cover 61.001 }
+      its(:cue_timing) { should cover 3661.001 }
+    end
+
+    context "when there is no identifier" do
+      let(:cue) { Voot::Cue.new(cue_timing: cue_timing, payload: "gordolf he is a beard") }
+
+      its(:identifier) { should be_nil }
+      its(:payload) { should == "gordolf he is a beard" }
+      its(:cue_timing) { should cover 61.001 }
+      its(:cue_timing) { should cover 3661.001 }
+    end
+  end
+
+  describe "#file_body" do
+    let(:vtt) { Voot::Vtt.new.tap { |vtt| vtt.cues << cue } }
+    let(:cue) { Voot::Cue.new(cue_timing: cue_timing, payload: "borgomar is a dumb") }
+    let(:parsed_input) { parser.file_body.parse(vtt.to_webvtt) }
+
+    context "when the header is not set" do
+
+      its(:header) { should be_nil }
+      its(:cues) { should have(1).cue }
+    end
+
+    context "when the header is set" do
+      before { vtt.header = "lerd of rang" }
+
+      its(:header) { should == "lerd of rang" }
+      its(:cues) { should have(1).cue }
+    end
+  end
+end

data/spec/lib/voot/vtt_spec.rb

@@ -19,7 +19,7 @@ describe Voot::Vtt do
     context "when the file exists" do
       let(:pesky_user_data) { "hey guys tacos are great right" }
 
-      before { File.write(vtt_path, pesky_user_data) }
+      before { File.open(vtt_path, "w") { |file| file << pesky_user_data } }
 
       it "clobbers the file content" do
         expect do
@@ -65,7 +65,7 @@ describe Voot::Vtt do
     context "when there is a cue" do
       before { vtt.cues << create_cue("not the drill!", 0, 2) }
 
-      its(:to_webvtt) { should == "WEBVTT\n\n00:00.000 --> 00:02.000\nnot the drill!" }
+      its(:to_webvtt) { should == "WEBVTT\n\n00:00:00.000 --> 00:00:02.000\nnot the drill!" }
     end
   end
 end

data/spec/lib/voot_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Voot do
+  let(:voot_path) { Tempfile.new("voot").path }
+
+  describe ".load" do
+    subject { Voot.load(voot_path) }
+
+    context "when the file is empty" do
+      it "fails to parse" do
+        expect { Voot.load(voot_path) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    context "when the file does not contain a webvtt header" do
+      before { File.open(voot_path, "w") { |file| file << "taco thursdays yo" } }
+
+      it "fails to parse" do
+        expect { Voot.load(voot_path) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    context "when the file contains a webvtt header" do
+      before { File.open(voot_path, "w") { |file| file << "WEBVTT" } }
+
+      its(:cues) { should be_empty }
+      its(:header) { should be_nil }
+      its(:path) { should == voot_path }
+    end
+
+    context "when the file contains a header" do
+      before { File.open(voot_path, "w") { |file| file << "WEBVTT presents bob ross classics" } }
+
+      its(:header) { should == "presents bob ross classics" }
+    end
+
+    context "when the file contains a junk-filled header" do
+      before { File.open(voot_path, "w") { |file| file << "WEBVTT\ni liek ppokemans" } }
+
+      it "fails to parse" do
+        expect { Voot.load(voot_path) }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    context "when the file contains cues" do
+      before { File.open(voot_path, "w") { |file| file << "WEBVTT\n\n00:00.000 --> 00:00.000\ndrugboat" } }
+
+      it { should have(1).cues }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 $:<< File.expand_path("../../lib", __FILE__)
 
 require "voot"
+require "tempfile"
+require "parslet/rig/rspec"
 
 Dir.glob(File.expand_path("../support/**/*.rb", __FILE__)) { |f| require f }
 

data/spec/support/cue_helper.rb

@@ -1,6 +1,12 @@
 module CueHelper
+  def create_timing(start, stop)
+    start_timestamp = Voot::Timestamp.new(start)
+    stop_timestamp = Voot::Timestamp.new(stop)
+    Voot::CueTiming.new(start_timestamp, stop_timestamp)
+  end
+
   def create_cue(payload, start, stop)
-    cue_timing = Voot::CueTiming.new(start_seconds: start, end_seconds: stop)
+    cue_timing = create_timing(start, stop)
     Voot::Cue.new(cue_timing: cue_timing, payload: payload)
   end
 end

data/voot.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = `git ls-files -- spec`.split("\n")
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "parslet"
+
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "guard-bundler"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: voot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Doc Ritezel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-30 00:00:00.000000000 Z
+date: 2013-07-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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
@@ -87,13 +101,20 @@ files:
 - lib/voot/cue.rb
 - lib/voot/cue_list.rb
 - lib/voot/cue_timing.rb
+- lib/voot/parser.rb
+- lib/voot/timestamp.rb
+- lib/voot/transform.rb
 - lib/voot/version.rb
 - lib/voot/vtt.rb
 - script/ci.sh
 - spec/lib/voot/cue_list_spec.rb
 - spec/lib/voot/cue_spec.rb
 - spec/lib/voot/cue_timing_spec.rb
+- spec/lib/voot/parser_spec.rb
+- spec/lib/voot/timestamp_spec.rb
+- spec/lib/voot/transform_spec.rb
 - spec/lib/voot/vtt_spec.rb
+- spec/lib/voot_spec.rb
 - spec/spec_helper.rb
 - spec/support/cue_helper.rb
 - voot.gemspec
@@ -125,6 +146,10 @@ test_files:
 - spec/lib/voot/cue_list_spec.rb
 - spec/lib/voot/cue_spec.rb
 - spec/lib/voot/cue_timing_spec.rb
+- spec/lib/voot/parser_spec.rb
+- spec/lib/voot/timestamp_spec.rb
+- spec/lib/voot/transform_spec.rb
 - spec/lib/voot/vtt_spec.rb
+- spec/lib/voot_spec.rb
 - spec/spec_helper.rb
 - spec/support/cue_helper.rb