edl 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92c9e98e3aae5318b201b581548227410c0add31
-  data.tar.gz: 775136de2ed133788783aabb995674b68bf610bf
+  metadata.gz: aa1756eb9a1a1e9d9c8703e5033741622df904c9
+  data.tar.gz: 513d2a6560317fa3fb5988d202219543bf8e0ebe
 SHA512:
-  metadata.gz: 64487e6d8b2558e74ae04781a347c2ed91d1c5ad362b764b0af479628077fd70ea831e1df7d1403afabcf794aa10deb1087fa484d7e46f23e70e555b07802ba7
-  data.tar.gz: 6eb2449c27c2188dcfe11df99b4a987d78436f938fdf7795bc996e7c22dc1d7c3f6b9c42a815f07b79238ae626e8e7b9a3d77576b393c8ed17bdc7151b4835c7
+  metadata.gz: 85afdd18d25b711ab61971ac813a79c202a6aa84363fdc47c50de4ca8525e322ca675a22e0002004482420075626ee8ea6dda7088c2d49070687bc6f8efc64d9
+  data.tar.gz: e6f3893517e8fc68311816f3b40119ab10d347662f6bb4f6708f78f353a94c74f6b79ffb8683d20b78e671ec11f1dda93a96ae5ecb942ac3532d0ff0bb429fde

data/{README.rdoc → LICENSE.txt}

@@ -1,44 +1,3 @@
-Work with EDL files from Ruby
-http://en.wikipedia.org/wiki/Edit_decision_list 
-
-The library assists in parsing [EDL files](http://en.wikipedia.org/wiki/Edit_decision_list) in CMX 3600 format.
-You can use it to generate capture lists, inspect needed video segments for the assembled program
-and display edit timelines.  Together with the depix you could write your own "blind"
-conform utility in about 10 minutes, no joke.
-
-== SYNOPSIS:
-
-   require 'rubygems'
-   require 'edl'
-   
-   list = EDL::Parser.new(fps=25).parse(File.open('OFFLINE.EDL'))
-   list.events.each do | evt |
-     evt.clip_name #=> Boat_Trip_Take1
-     evt.capture_from_tc #=> 01:20:22:10
-     evt.capture_to_tc #=> 01:20:26:15, accounts for outgoing transition AND M2 timewarps
-   end
-  
-== REQUIREMENTS:
-
-* Timecode gem (sudo gem install timecode)
-
-== PROBLEMS:
-
-There is currently no support for:
-
-* drop-frame TC
-* audio
-* split edits
-* key effects
-
-Some reverse/timewarp combinations can produce source dificiencies of 1 frame
-
-== INSTALL:
-
-* sudo gem install edl
-
-== LICENSE:
-
 (The MIT License)
 
 Copyright (c) 2008 Julik Tarkhanov <me@julik.nl>

data/README.md

@@ -0,0 +1,48 @@
+Work with EDL files from Ruby
+http://en.wikipedia.org/wiki/Edit_decision_list 
+
+The library assists in parsing [EDL files](http://en.wikipedia.org/wiki/Edit_decision_list) in CMX 3600 format.
+You can use it to generate capture lists, inspect needed video segments for the assembled program
+and display edit timelines. When used together with [depix](https://github.com/guerilla-di/depix) you could write your own "blind"
+conform utility in about 10 minutes, no joke.
+
+## Basic usage
+
+```
+require 'rubygems'
+require 'edl'
+
+list = EDL::Parser.new(fps=25).parse(File.open('OFFLINE.EDL'))
+list.events.each do | evt |
+ evt.clip_name #=> Boat_Trip_Take1
+ evt.capture_from_tc #=> 01:20:22:10
+ evt.capture_to_tc #=> 01:20:26:15, accounts for outgoing transition AND M2 timewarps
+end
+```
+
+## Requirements
+
+* Timecode gem (sudo gem install timecode)
+
+## Currently unsupportedl EDL features:
+
+There is currently no support for:
+
+* drop-frame TC
+* audio
+* split edits
+* key effects
+
+Some reverse/timewarp combinations can produce source dificiencies of 1 frame
+
+## Installation
+
+Add the following to your project `Gemfile`:
+
+```
+gem 'edl'
+```
+
+## License
+
+See LICENSE.txt

data/Rakefile

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
 require 'rubygems'
-require 'bundler/gem_tasks'
+require './lib/edl.rb'
 require 'rake/testtask'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
 
-begin
-  require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
-  RSpec::Core::RakeTask.new(:spec)
-
-  task default: :spec
-rescue LoadError
-  # no rspec available
-end
+task default: :spec

data/edl.gemspec

@@ -6,18 +6,26 @@ $LOAD_PATH.push File.expand_path('../lib', __FILE__)
 require 'edl/version'
 
 Gem::Specification.new do |s|
+  s.required_rubygems_version = ">= 1.2.0"
+
   s.name = 'edl'
   s.version = EDL::VERSION
-
-  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
-  s.authors = ['Julik Tarkhanov']
+  s.authors = ['Julik Tarkhanov', 'Philipp Großelfinger']
   s.date = '2014-03-24'
   s.email = 'me@julik.nl'
   s.extra_rdoc_files = [
-    'README.rdoc'
+    'README.md'
   ]
 
-  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  # Prevent pushing this gem to RubyGemspec.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if s.respond_to?(:metadata)
+    s.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushespec."
+  end
+  
+  s.files         = `git ls-files -z`.split("\x0")
   s.bindir        = 'exe'
   s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
   s.require_paths = ['lib']
@@ -27,19 +35,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = '2.0.3'
   s.summary = 'Parser for EDL (Edit Decision List) files'
 
-  if s.respond_to? :specification_version
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0')
-      s.add_runtime_dependency 'timecode', '>= 0'
-      s.add_development_dependency 'rake', '>= 0'
-      s.add_development_dependency 'rspec', '~> 3.5'
-    else
-      s.add_dependency 'timecode', '>= 0'
-      s.add_dependency 'rake', '>= 0'
-    end
-  else
-    s.add_dependency 'timecode', '>= 0'
-    s.add_dependency 'rake', '>= 0'
-  end
+  s.add_runtime_dependency 'timecode', '>= 0'
+  s.add_development_dependency 'rake', '>= 0'
+  s.add_development_dependency 'rspec', '~> 3.5'
 end

data/lib/edl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EDL
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
 end

data/spec/fixtures/files/45S_SAMPLE.EDL

@@ -0,0 +1,48 @@
+TITLE:   EDIT 15 [14-11-08] 45 SEC EDL 
+001  106771   V     C        04:00:57:05 04:00:58:10 10:00:00:00 10:00:01:05 
+002  106771   V     C        04:03:44:06 04:03:45:08 10:00:01:05 10:00:02:07 
+003  106770   V     C        00:06:55:13 00:06:57:01 10:00:02:07 10:00:03:20 
+004  106771   V     C        03:16:35:05 03:16:36:05 10:00:03:20 10:00:04:20 
+005  106770   V     C        00:13:03:17 00:13:04:20 10:00:04:20 10:00:05:23 
+006  106771   V     C        03:11:43:02 03:11:44:04 10:00:05:23 10:00:07:00 
+007  106857   V     C        07:18:40:24 07:18:41:17 10:00:07:00 10:00:07:18 
+008  106857   V     C        07:22:25:19 07:22:27:02 10:00:07:18 10:00:09:01 
+009  106863   V     C        13:12:46:23 13:12:48:11 10:00:09:01 10:00:10:14 
+010  106857   V     C        08:00:32:00 08:00:33:10 10:00:10:14 10:00:11:24 
+011  106857   V     C        08:05:36:18 08:05:37:19 10:00:11:24 10:00:13:00 
+012  106857   V     C        07:04:47:06 07:04:50:13 10:00:13:00 10:00:16:07 
+M2   106857         012.5                07:04:47:06 
+013  106863   V     C        10:11:06:07 10:11:08:00 10:00:16:07 10:00:18:00 
+014  106863   V     C        10:09:16:21 10:09:18:11 10:00:18:00 10:00:19:15 
+015  106857   V     C        07:06:02:17 07:06:04:07 10:00:19:15 10:00:21:05 
+016  106857   V     C        09:07:18:07 09:07:20:16 10:00:21:05 10:00:23:14 
+M2   106857         002.5                09:07:18:07 
+017  106863   V     C        11:02:46:06 11:02:47:06 10:00:23:14 10:00:24:14 
+018  106863   V     C        11:10:17:04 11:10:17:20 10:00:24:14 10:00:25:05 
+019  106863   V     C        12:06:09:18 12:06:10:16 10:00:25:05 10:00:26:03 
+020  106863   V     C        12:10:49:17 12:10:51:02 10:00:26:03 10:00:27:13 
+021  106815   V     C        05:01:22:21 05:01:24:05 10:00:27:13 10:00:28:22 
+022  106815   V     C        06:01:35:03 06:01:36:18 10:00:28:22 10:00:30:12 
+023  106815   V     C        05:13:38:19 05:13:40:10 10:00:30:12 10:00:32:03 
+M2   106815        -025.0                05:13:38:19 
+024  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
+M2   106857        -025.0                09:13:03:09 
+025  106857   V     C        09:13:01:07 09:13:01:07 10:00:34:05 10:00:34:05 
+025  106771   V     D    022 03:11:55:00 03:11:56:17 10:00:34:05 10:00:35:22 
+M2   106857        -025.0                09:13:01:07 
+* BLEND, DISSOLVE 
+026  106771   V     C        03:11:56:17 03:11:56:17 10:00:35:22 10:00:35:22 
+026  106771   V     D    012 03:06:30:09 03:06:31:19 10:00:35:22 10:00:37:07 
+* BLEND, DISSOLVE 
+027  106863   V     C        13:15:29:20 13:15:31:02 10:00:37:07 10:00:38:14 
+028  106771   V     C        03:15:40:22 03:15:42:11 10:00:38:14 10:00:40:03 
+029  106863   V     C        13:15:51:02 13:15:52:08 10:00:40:03 10:00:41:09 
+030  106863   V     C        13:15:52:08 13:15:52:08 10:00:41:09 10:00:41:09 
+030     BL    V     D    032 00:00:00:00 00:00:01:07 10:00:41:09 10:00:42:16 
+* BLEND, DISSOLVE 
+>>> SOURCE 106770   106770           4919975f.793b8d33 
+>>> SOURCE 106771   106771           4919a179.79630563 
+>>> SOURCE 106815   106815           4919b521.79afcb70 
+>>> SOURCE 106857   106857           4919cbb9.7a080d9d 
+>>> SOURCE 106863   106863           4919e0c3.7a5a3cfc 
+

data/spec/fixtures/files/FCP_REVERSE.EDL

@@ -0,0 +1,9 @@
+TITLE: REVSIMPLE
+FCM: NON-DROP FRAME
+
+001  FOO      V     C        01:00:39:23 01:01:19:23 01:00:00:00 01:00:40:00  
+* FROM CLIP NAME:  BARS_40S.MOV
+* COMMENT: 
+M2   FOO           -025.0                01:00:39:23
+
+

data/spec/fixtures/files/KEY_TRANSITION.EDL

@@ -0,0 +1,9 @@
+TITLE: FOR_TEST
+FCM: DROP FRAME
+
+002        AX V     K B      00:01:06:06 00:01:08:03 01:00:04:10 01:00:06:07  
+002        AX V     K    000 00:00:03:08 00:00:03:08 01:00:04:10 01:00:04:10  
+* FROM CLIP NAME:  foobarz_0118_023-APPLE PRORES WITH ALPHA.MOV
+* COMMENT: 
+* KEY CLIP NAME:  foobarz_0118_026-APPLE PRORES WITH ALPHA.MOV
+* CLIP FILTER: COLOR CORRECTOR 3-WAY

data/spec/fixtures/files/PLATES.EDL

@@ -0,0 +1 @@
+TITLE:   PLATES.

data/spec/fixtures/files/REEL_IS_CLIP.txt

@@ -0,0 +1,8 @@
+0001 KASS1 A1234V C        00:00:00:00 00:00:12:24  10:00:00:00 10:00:12:24
+* REEL RC100009 IS CLIP 28661.mov
+0002 KASS1 A1234V C        00:00:00:00 00:00:13:03  10:00:12:24 10:00:26:02
+* REEL RC100003 IS CLIP 28655.mov
+0003 KASS1 A1234V C        00:00:00:00 00:00:15:06  10:00:26:02 10:00:41:08
+* REEL RC100005 IS CLIP 28657.mov
+0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14
+* REEL RC100010 IS CLIP 28662.mov

data/spec/fixtures/files/REVERSE.EDL

@@ -0,0 +1,3 @@
+TITLE:   REVERSED_EDL 
+001  106857   V     C        09:13:03:09 09:13:05:11 10:00:32:03 10:00:34:05 
+M2   106857        -025.0                09:13:03:09 

data/spec/fixtures/files/SIMPLE_DISSOLVE.EDL

@@ -0,0 +1,9 @@
+TITLE: SIMPLE_DISSOLVE
+FCM: NON-DROP FRAME
+
+001        BL V     C        00:00:00:00 00:00:00:00 01:00:00:00 01:00:00:00  
+001  006I     V     D    043 06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
+* EFFECT NAME: CROSS DISSOLVE
+* TO CLIP NAME:  TAPE_6-10.MOV
+* COMMENT: 
+

data/spec/fixtures/files/SPEEDUP_AND_FADEOUT.EDL

@@ -0,0 +1,11 @@
+TITLE: SPEEDUP_AND_FADEOUT
+FCM: NON-DROP FRAME
+
+001  FOO      V     C        01:00:00:00 01:00:27:14 01:00:00:00 01:00:27:14  
+001        BL V     D    025 00:00:00:00 00:00:01:00 01:00:27:14 01:00:28:14  
+* EFFECT NAME: CROSS DISSOLVE
+* FROM CLIP NAME:  BARS_40S.MOV
+* COMMENT: 
+M2   FOO            035.0                01:00:00:00
+
+

data/spec/fixtures/files/SPEEDUP_REVERSE_AND_FADEOUT.EDL

@@ -0,0 +1,11 @@
+TITLE: TESTREV
+FCM: NON-DROP FRAME
+
+001  FOO      V     C        01:00:39:23 01:01:07:12 01:00:00:00 01:00:27:14  
+001        BL V     D    025 00:00:00:00 00:00:01:00 01:00:27:14 01:00:28:14  
+* EFFECT NAME: CROSS DISSOLVE
+* FROM CLIP NAME:  BARS_40S.MOV
+* COMMENT: 
+M2   FOO           -035.0                01:00:39:23
+
+

data/spec/fixtures/files/SPLICEME.EDL

@@ -0,0 +1,5 @@
+TITLE: SPLICEME
+FCM: NON-DROP FRAME
+
+001  006I     V     C        06:42:50:18 06:42:52:13 01:00:00:00 01:00:01:20  
+002  006I     V     C        06:42:52:14 06:42:52:16 01:00:10:21 01:00:10:23

data/spec/fixtures/files/TIMEWARP.EDL

@@ -0,0 +1,5 @@
+TITLE: TIMEWARP_EDL
+FCM: NON-DROP FRAME
+
+001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
+M2   003            309.6                03:03:19:19

data/spec/fixtures/files/TIMEWARP_HALF.EDL

@@ -0,0 +1,5 @@
+TITLE: TIMEWARP_HALF_EDL
+FCM: NON-DROP FRAME
+
+001  003      V     C        03:03:19:19 03:03:20:04 01:00:04:03 01:00:04:13  
+M2   003            12.5                03:03:19:19

data/spec/fixtures/files/edl_mixed_line_endings.edl

@@ -0,0 +1,12 @@
+TITLE: EDL_TEST
+FCM: NON-DROP FRAME
+
+000001 A001C004_130917 V C 01:23:39:00 01:23:49:01 10:02:51:10 10:03:01:11
+* A
+* B
+* C
+* D
+* E
+* F
+* G
+

data/spec/lib/edl/parser_spec.rb

@@ -0,0 +1,12 @@
+describe EDL::Parser do
+  describe '#parse' do
+    it 'reports error when frame exceeds fps' do
+      Timecode.add_custom_framerate!(12.0)
+      parser = EDL::Parser.new(12)
+      parser.parse(File.read('spec/fixtures/files/45S_SAMPLE.EDL'))
+      expect(parser.errors.first).to match(
+        /There can be no more than 12\.0 frames \@12\.0, got 13/
+      )
+    end
+  end
+end

data/spec/lib/edl_spec.rb

@@ -0,0 +1,739 @@
+# frozen_string_literal: true
+
+TRAILER_EDL                 = 'spec/fixtures/files/TRAILER_EDL.edl'
+SIMPLE_DISSOLVE             = 'spec/fixtures/files/SIMPLE_DISSOLVE.EDL'
+SPLICEME                    = 'spec/fixtures/files/SPLICEME.EDL'
+SIMPLE_TIMEWARP             = 'spec/fixtures/files/TIMEWARP.EDL'
+SLOMO_TIMEWARP              = 'spec/fixtures/files/TIMEWARP_HALF.EDL'
+FORTY_FIVER                 = 'spec/fixtures/files/45S_SAMPLE.EDL'
+AVID_REVERSE                = 'spec/fixtures/files/REVERSE.EDL'
+SPEEDUP_AND_FADEOUT         = 'spec/fixtures/files/SPEEDUP_AND_FADEOUT.EDL'
+SPEEDUP_REVERSE_AND_FADEOUT = 'spec/fixtures/files/SPEEDUP_REVERSE_AND_FADEOUT.EDL'
+FCP_REVERSE                 = 'spec/fixtures/files/FCP_REVERSE.EDL'
+PLATES                      = 'spec/fixtures/files/PLATES.EDL'
+KEY                         = 'spec/fixtures/files/KEY_TRANSITION.EDL'
+CLIP_NAMES                  = 'spec/fixtures/files/REEL_IS_CLIP.txt'
+MIXED_LINEBREAKS            = 'spec/fixtures/files/edl_mixed_line_endings.edl'
+
+class String
+  def tc(fps = Timecode::DEFAULT_FPS)
+    Timecode.parse(self, fps)
+  end
+end
+
+describe EDL do
+  describe 'An Event' do
+    it 'support hash initialization' do
+      evt = EDL::Event.new(src_start_tc: '01:00:00:00'.tc)
+      expect('01:00:00:00'.tc).to eq evt.src_start_tc
+    end
+
+    it 'support block initialization' do
+      evt = EDL::Event.new do |e|
+        e.src_start_tc = '01:00:00:04'.tc
+      end
+      expect('01:00:00:04'.tc).to eq evt.src_start_tc
+    end
+
+    it 'respond to ends_with_transition? with false if outgoing_transition_duration is zero' do
+      evt = EDL::Event.new
+      evt.outgoing_transition_duration = 0
+      expect(evt.ends_with_transition?).to be_falsey
+    end
+
+    it 'respond to ends_with_transition? with true if outgoing_transition_duration set above zero' do
+      evt = EDL::Event.new
+      evt.outgoing_transition_duration = 24
+      expect(evt.ends_with_transition?).to be_truthy
+    end
+
+    it 'respond to has_timewarp? with false if no timewarp assigned' do
+      evt = EDL::Event.new(timewarp: nil)
+      expect(evt.has_timewarp?).to be_falsey
+    end
+
+    it 'respond to has_timewarp? with true if a timewarp  is assigned' do
+      evt = EDL::Event.new(timewarp: true)
+      expect(evt.has_timewarp?).to be_truthy
+    end
+
+    it 'report rec_length as a difference of record timecodes' do
+      evt = EDL::Event.new(rec_start_tc: '1h'.tc, rec_end_tc: '1h 10s 2f'.tc)
+      expect('10s 2f'.tc.to_i).to eq evt.rec_length
+    end
+
+    it 'report rec_length_with_transition as a difference of record timecodes if no transition set' do
+      evt = EDL::Event.new(rec_start_tc: '1h'.tc, rec_end_tc: '1h 10s 2f'.tc, outgoing_transition_duration: 0)
+      expect('10s 2f'.tc.to_i).to eq evt.rec_length_with_transition
+    end
+
+    it 'add transition length to rec_length_with_transition if a transition is set' do
+      evt = EDL::Event.new(rec_start_tc: '1h'.tc, rec_end_tc: '1h 10s 2f'.tc, outgoing_transition_duration: 10)
+      expect('10s 2f'.tc.to_i + 10).to eq evt.rec_length_with_transition
+    end
+
+    it 'return a default array for comments' do
+      expect(EDL::Event.new.comments).to be_a(Enumerable)
+    end
+
+    it 'respond false to has_transition? if incoming transition is set' do
+      expect(EDL::Event.new(transition: nil).has_transition?).to be_falsey
+    end
+
+    it 'respond true to has_transition? if incoming transition is set' do
+      expect(EDL::Event.new(transition: true).has_transition?).to be_truthy
+    end
+
+    it 'respond true to black? if reel is BL' do
+      expect(EDL::Event.new(reel: 'BL')).to be_black
+      expect(EDL::Event.new(reel: '001')).to_not be_black
+    end
+
+    it 'respond true to generator? if reel is BL or AX' do
+      expect(EDL::Event.new(reel: 'BL')).to be_generator
+      expect(EDL::Event.new(reel: 'AX')).to be_generator
+      expect(EDL::Event.new(reel: '001')).to_not be_generator
+    end
+
+    it 'report src_length as rec_length_with_transition' do
+      e = EDL::Event.new(rec_start_tc: '2h'.tc, rec_end_tc: '2h 2s'.tc)
+      expect('2s'.tc.to_i).to eq e.src_length
+    end
+
+    it 'support line_number' do
+      expect(EDL::Event.new.line_number).to be_nil
+      expect(3).to eq EDL::Event.new(line_number: 3).line_number
+    end
+
+    it 'support capture_length as an alias to src_length' do
+      tw = double
+      expect(tw).to receive(:actual_length_of_source).twice.and_return(:something)
+      e = EDL::Event.new(timewarp: tw)
+      expect(e.capture_length).to eq e.src_length
+    end
+
+    it 'delegate src_length to the timewarp if it is there' do
+      tw = double
+      expect(tw).to receive(:actual_length_of_source).and_return(:something)
+      e = EDL::Event.new(timewarp: tw)
+      expect(:something).to eq e.src_length
+    end
+
+    it 'report reverse? and reversed? based on the timewarp' do
+      e = EDL::Event.new(timewarp: nil)
+      expect(e).to_not be_reverse
+      expect(e).to_not be_reversed
+
+      tw = double
+      expect(tw).to receive(:reverse?).twice.and_return(true)
+
+      e = EDL::Event.new(timewarp: tw)
+      expect(e).to be_reverse
+      expect(e).to be_reversed
+    end
+
+    it 'report speed as 100 percent without a timewarp' do
+      e = EDL::Event.new
+      expect(100.0).to eq e.speed
+    end
+
+    it 'consult the timewarp for speed' do
+      tw = double
+      expect(tw).to receive(:speed).and_return(:something)
+
+      e = EDL::Event.new(timewarp: tw)
+      expect(:something).to eq e.speed
+    end
+
+    it 'report false for starts_with_transition? if transision is nil' do
+      expect(EDL::Event.new.starts_with_transition?).to be_falsey
+    end
+
+    it 'report zero for incoming_transition_duration if transision is nil' do
+      expect(EDL::Event.new.incoming_transition_duration).to be_zero
+    end
+
+    it 'report true for starts_with_transition? if transision is not nil' do
+      e = EDL::Event.new transition: true
+      expect(e.starts_with_transition?).to be_truthy
+    end
+
+    it "consult the transition for incoming_transition_duration if it's present" do
+      tr = double
+      expect(tr).to receive(:duration).and_return(:something)
+
+      e = EDL::Event.new(transition: tr)
+      expect(:something).to eq e.incoming_transition_duration
+    end
+
+    it 'report capture_from_tc as the source start without a timewarp' do
+      e = EDL::Event.new(src_start_tc: '1h'.tc)
+      expect('1h'.tc).to eq e.capture_from_tc
+    end
+
+    it 'consult the timewarp for capture_from_tc if a timewarp is there' do
+      tw = double
+      expect(tw).to receive(:source_used_from).and_return(:something)
+
+      e = EDL::Event.new(timewarp: tw)
+      expect(:something).to eq e.capture_from_tc
+    end
+
+    it 'report capture_to_tc as record length plus transition when no timewarp present' do
+      e = EDL::Event.new(src_end_tc: '1h 10s'.tc, outgoing_transition_duration: 2)
+      expect('1h 10s 2f'.tc).to eq e.capture_to_tc
+    end
+
+    it 'report capture_to_and_including_tc as record length plus transition when no timewarp present' do
+      e = EDL::Event.new(src_end_tc: '1h 10s'.tc, outgoing_transition_duration: 2)
+      expect('1h 10s 1f'.tc).to eq e.capture_to_and_including_tc
+    end
+
+    it 'consult the timewarp for capture_to_tc if timewarp is present' do
+      tw = double
+      expect(tw).to receive(:source_used_upto).and_return(:something)
+
+      e = EDL::Event.new(timewarp: tw)
+      expect(:something).to eq e.capture_to_tc
+    end
+  end
+
+  describe 'A Parser' do
+    it 'store the passed framerate' do
+      p = EDL::Parser.new(45)
+      expect(45).to eq p.fps
+    end
+
+    it 'return matchers tuned with the passed framerate' do
+      p = EDL::Parser.new(30)
+      matchers = p.get_matchers
+      event_matcher = matchers.find { |e| e.is_a?(EDL::EventMatcher) }
+      expect(30).to eq event_matcher.fps
+    end
+
+    it 'create a Timecode from stringified elements' do
+      elems = %w[08 04 24 24]
+      expect do
+        @tc = EDL::Parser.timecode_from_line_elements(elems, 30)
+      end.to_not raise_error
+
+      expect(@tc).to be_a(Timecode)
+      expect('08:04:24:24'.tc(30)).to eq @tc
+
+      expect(elems).to be_empty
+    end
+
+    it 'parse from a String' do
+      p = EDL::Parser.new
+      expect do
+        @edl = p.parse File.read(SIMPLE_DISSOLVE)
+      end.to_not raise_error
+
+      expect(@edl).to be_a(EDL::List)
+      expect(@edl.length).to eq 2
+    end
+
+    it 'parse from a File/IOish' do
+      p = EDL::Parser.new
+      expect do
+        @edl = p.parse File.open(SIMPLE_DISSOLVE)
+      end.to_not raise_error
+
+      expect(@edl).to be_a(EDL::List)
+      expect(@edl.length).to eq 2
+    end
+
+    it 'properly parse a dissolve' do
+      # TODO: reformulate
+      p = EDL::Parser.new
+      @edl = p.parse File.open(SIMPLE_DISSOLVE)
+
+      first, second = @edl
+
+      expect(first).to be_a(EDL::Event)
+      expect(second).to be_a(EDL::Event)
+
+      expect(second.has_transition?).to be_truthy
+      expect(first.ends_with_transition?).to be_truthy
+      expect(second.ends_with_transition?).to be_falsey
+
+      no_trans = @edl.without_transitions
+
+      expect(2).to eq no_trans.length
+      target_tc = (Timecode.parse('01:00:00:00') + 43)
+      expect(target_tc).to eq(no_trans[0].rec_end_tc),
+                           'The iitshould have been extended by the length of the dissolve'
+
+      target_tc = Timecode.parse('01:00:00:00')
+      expect(target_tc).to eq no_trans[1].rec_start_tc
+      'The oitshould have been left in place'
+    end
+
+    it 'return a spliced EDL if the sources allow' do
+      @spliced = EDL::Parser.new.parse(File.open(SPLICEME)).spliced
+
+      expect(1).to eq @spliced.length
+      evt = @spliced[0]
+
+      expect('06:42:50:18'.tc).to eq evt.src_start_tc
+      expect('06:42:52:16'.tc).to eq evt.src_end_tc
+    end
+
+    it 'not apply any Matchers if a match is found' do
+      p = EDL::Parser.new
+      m1 = double
+      expect(m1).to receive(:matches?).with('plop').and_return(true)
+      expect(m1).to receive(:apply)
+
+      expect(p).to receive(:get_matchers).and_return([m1, m1])
+      result = p.parse('plop')
+      expect(result).to be_empty
+    end
+
+    it 'register line numbers of the detected events' do
+      p = EDL::Parser.new
+      events = p.parse(File.open(SPLICEME))
+
+      expect(4).to eq events[0].line_number
+      expect(5).to eq events[1].line_number
+    end
+  end
+
+  describe 'A TimewarpMatcher' do
+    it 'not create any extra events when used within a Parser' do
+      @edl = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP))
+      expect(1).to eq @edl.length
+    end
+
+    it 'properly describe a speedup' do
+      clip = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP)).pop
+
+      tw = clip.timewarp
+
+      expect(tw).to be_a(EDL::Timewarp)
+      expect(tw.source_used_upto).to be > clip.src_end_tc
+
+      expect(clip.src_start_tc).to eq tw.source_used_from
+      expect(124).to eq clip.timewarp.actual_length_of_source
+      expect(tw).to_not be_reverse
+    end
+
+    it 'properly describe a slomo' do
+      clip = EDL::Parser.new.parse(File.open(SLOMO_TIMEWARP)).pop
+
+      expect(10).to eq clip.rec_length
+      expect(5).to eq clip.src_length
+
+      tw = clip.timewarp
+
+      expect(tw.source_used_upto).to be < clip.src_end_tc
+
+      expect('03:03:19:24'.tc).to eq tw.source_used_upto
+
+      expect(50).to eq tw.speed_in_percent.to_i
+      expect(5).to eq tw.actual_length_of_source
+      expect(tw).to_not be_reverse
+    end
+  end
+
+  describe 'A reverse timewarp EDL coming from Avid' do
+    it 'be parsed properly' do
+      clip = EDL::Parser.new.parse(File.open(AVID_REVERSE)).pop
+
+      expect(52).to eq clip.rec_length
+
+      tw = clip.timewarp
+
+      expect(-25).to eq tw.actual_framerate.to_i
+      expect(tw).to be_reverse
+      expect(52).to eq tw.actual_length_of_source
+
+      expect(-100.0).to eq(clip.timewarp.speed), 'should be computed the same as its just a reverse'
+    end
+  end
+
+  describe 'EDL with clip reels in comments' do
+    it 'parse clip names into the reel field' do
+      clips = EDL::Parser.new.parse(File.open(CLIP_NAMES))
+      # flunk "This still has to be finalized"
+    end
+  end
+
+  describe 'A Final Cut Pro originating reverse' do
+    it 'be interpreted properly' do
+      e = EDL::Parser.new.parse(File.open(FCP_REVERSE)).pop
+
+      expect(1000).to eq e.rec_length
+      expect(1000).to eq e.src_length
+
+      expect('1h'.tc).to eq e.rec_start_tc
+      expect('1h 40s'.tc).to eq e.rec_end_tc
+
+      expect(e).to be_reverse
+      expect(e.timewarp).to_not be_nil
+
+      tw = e.timewarp
+
+      expect(-100).to eq tw.speed
+      expect(e.speed).to eq tw.speed
+
+      expect('1h'.tc).to eq tw.source_used_from
+      expect('1h 40s'.tc).to eq tw.source_used_upto
+    end
+  end
+
+  # describe "An edit with keyer transition" do
+  #   itould "parse correctly" do
+  #     events = EDL::Parser.new.parse(File.open(KEY))
+  #     expect(2).to eq events.length
+  #     flunk "Key transition processing is not reliable yet - no reference"
+  #   end
+  # end
+
+  describe 'EventMatcher' do
+    EVT_PATTERNS = [
+      '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17',
+      '021  009      V     C        00:39:04:21 00:39:05:09 01:00:26:17 01:00:27:05',
+      '022  008C     V     C        08:08:01:23 08:08:02:18 01:00:27:05 01:00:28:00',
+      '023  008C     V     C        08:07:30:02 08:07:30:21 01:00:28:00 01:00:28:19',
+      '024        AX V     C        00:00:00:00 00:00:01:00 01:00:28:19 01:00:29:19',
+      '025        BL V     C        00:00:00:00 00:00:00:00 01:00:29:19 01:00:29:19',
+      '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20',
+      '002  REDACTED V     C        03:09:00:13 03:09:55:19 01:00:43:12 01:01:38:18',
+      #    '0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14'
+    ].freeze
+
+    #  ituld 'handle the event with multiple audio tracks' do
+    #    m = EDL::EventMatcher.new(25)
+    #
+    #    clip = m.apply([],
+    #      '0004 KASS1 A1234V C        00:00:00:00 00:00:16:06  10:00:41:08 10:00:57:14'
+    #    )
+    #    expect(clip).to be_a(EDL::Event)
+    #    expect("A1234").to eq clip.track
+    #  end
+
+    it 'produce an Event' do
+      m = EDL::EventMatcher.new(25)
+
+      clip = m.apply([],
+                     '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17')
+
+      expect(clip).to be_a(EDL::Event)
+
+      expect('020').to eq clip.num
+      expect('008C').to eq clip.reel
+      expect('V').to eq clip.track
+
+      expect('08:04:24:24'.tc).to eq clip.src_start_tc
+
+      expect('08:04:25:19'.tc).to eq clip.src_end_tc
+      expect('01:00:25:22'.tc).to eq clip.rec_start_tc
+      expect('01:00:26:17'.tc).to eq clip.rec_end_tc
+
+      expect(clip.transition).to be_nil
+      expect(clip.timewarp).to be_nil
+      expect(clip.outgoing_transition_duration).to be_zero
+    end
+
+    it 'produce an Event when reel has dots and output a warning' do
+      m = EDL::EventMatcher.new(25)
+
+      # flexmock($stderr).should_receive(:puts).with("Reel name \"TIRED_EDITOR.MOV\" contains dots or spaces, beware.")
+
+      clip = m.apply([],
+                     '020  TIREDEDITOR.MOV     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17')
+
+      expect(clip).to be_a(EDL::Event)
+
+      expect('020').to eq clip.num
+      expect('TIREDEDITOR.MOV').to eq clip.reel
+      expect('V').to eq clip.track
+
+      expect('08:04:24:24'.tc).to eq clip.src_start_tc
+    end
+    
+    it 'produce an Event when reel has asterisks' do
+      m = EDL::EventMatcher.new(25)
+      
+      clip = m.apply([],
+                    '047  *TIRED*EDITOR* V     C        00:00:38:15 00:00:39:08 01:06:37:03 01:06:37:20 ')
+      
+      expect(clip).to be_a(EDL::Event)
+      
+      expect('047').to eq clip.num
+      expect('*TIRED*EDITOR*').to eq clip.reel
+      expect('V').to eq clip.track
+      
+      expect('00:00:38:15'.tc).to eq clip.src_start_tc
+    end
+
+    it 'produce an Event with dissolve' do
+      m = EDL::EventMatcher.new(25)
+
+      dissolve = m.apply([],
+                         '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20')
+      expect(dissolve).to be_a(EDL::Event)
+
+      expect('025').to eq dissolve.num
+      expect('GEN').to eq dissolve.reel
+      expect('V').to eq dissolve.track
+      expect(dissolve.has_transition?).to be_truthy
+
+      tr = dissolve.transition
+
+      expect(tr).to be_a(EDL::Dissolve)
+      expect(25).to eq tr.duration
+    end
+
+    it 'produce a vanilla Event with proper source length' do
+      # This one has EXACTLY 4 frames of source
+      m = EDL::EventMatcher.new(25)
+      clip = m.apply([], '001  GEN      V     C        00:01:00:00 00:01:00:04 01:00:00:00 01:00:00:04')
+      expect(clip).to be_a(EDL::Event)
+      expect(4).to eq clip.src_length
+    end
+
+    it 'set flag on the previous event in the stack when a dissolve is encountered' do
+      m = EDL::EventMatcher.new(25)
+      previous_evt = double
+      expect(previous_evt).to receive(:outgoing_transition_duration=).with(25)
+
+      m.apply([previous_evt],
+              '025  GEN      V     D    025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20')
+    end
+
+    it 'generate a Wipe' do
+      m = EDL::EventMatcher.new(25)
+      wipe = m.apply([],
+                     '025  GEN      V     W001  025 00:00:55:10 00:00:58:11 01:00:29:19 01:00:32:20')
+
+      tr = wipe.transition
+      expect(tr).to be_a(EDL::Wipe)
+      expect(25).to eq tr.duration
+      expect('001').to eq tr.smpte_wipe_index
+    end
+
+    EVT_PATTERNS.each do |pat|
+      it "match #{pat.inspect}" do
+        expect(EDL::EventMatcher.new(25).matches?(pat)).to be_truthy
+      end
+    end
+
+    it 'pass the framerate that it received upon instantiation to the Timecodes being created' do
+      m = EDL::EventMatcher.new(30)
+      clip = m.apply([],
+                     '020  008C     V     C        08:04:24:24 08:04:25:19 01:00:25:22 01:00:26:17')
+      expect(30).to eq clip.rec_start_tc.fps
+      expect(30).to eq clip.rec_end_tc.fps
+      expect(30).to eq clip.src_start_tc.fps
+      expect(30).to eq clip.src_end_tc.fps
+    end
+  end
+
+  describe 'CommentMatcher' do
+    it 'match a comment' do
+      line = '* COMMENT: PURE GARBAGE'
+      expect(EDL::CommentMatcher.new.matches?(line)).to be_truthy
+    end
+    
+    it 'match a comment that that contains an asterisk' do
+      line = '* COMMENT: PURE *GARBAGE*'
+      expect(EDL::CommentMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'apply the comment to the last clip on the stack' do
+      line = '* COMMENT: PURE GARBAGE'
+
+      comments = []
+      mok_evt = double
+
+      expect(mok_evt).to receive(:comments).exactly(3).times.and_return(comments)
+      2.times { EDL::CommentMatcher.new.apply([mok_evt], line) }
+
+      expect(['* COMMENT: PURE GARBAGE', '* COMMENT: PURE GARBAGE']).to eq mok_evt.comments
+    end
+  end
+
+  describe 'FallbackMatcher' do
+    it 'match anything' do
+      line = 'SOME'
+      expect(EDL::FallbackMatcher.new.matches?(line)).to be_truthy
+
+      line = 'OR ANOTHER  '
+      expect(EDL::FallbackMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'not match whitespace' do
+      line = "\s\s\s\r\n\r"
+      expect(EDL::FallbackMatcher.new.matches?(line)).to be_falsey
+    end
+
+    it 'append the matched content to comments' do
+      e = double
+      cmts = []
+      expect(e).to receive(:comments).twice.and_return(cmts)
+
+      EDL::FallbackMatcher.new.apply([e], 'FOOBAR')
+      expect(['FOOBAR']).to eq cmts
+
+      EDL::FallbackMatcher.new.apply([e], 'FINAL CUT PRO REEL: 006-I REPLACED BY: 006I')
+      expect(['FOOBAR', 'FINAL CUT PRO REEL: 006-I REPLACED BY: 006I']).to eq cmts
+    end
+
+    it 'raise an ApplyError if no clip is on the stack' do
+      expect do
+        EDL::FallbackMatcher.new.apply([], 'FINAL CUT PRO REEL: 006-I REPLACED BY: 006I')
+      end.to raise_error(EDL::Matcher::ApplyError)
+    end
+  end
+
+  describe 'ClipNameMatcher' do
+    it 'match a clip name' do
+      line = '* FROM CLIP NAME:  TAPE_6-10.MOV'
+      expect(EDL::NameMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'match a clip name without space after star' do
+      line = '*FROM CLIP NAME:  TAPE_6-10.MOV'
+      expect(EDL::NameMatcher.new.matches?(line)).to be_truthy
+    end
+    
+    it 'match a clip name containing an asterisk' do
+      line = '* FROM CLIP NAME:  18B_1*'
+      expect(EDL::NameMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'not match a simple comment' do
+      line = '* JUNK'
+      expect(EDL::NameMatcher.new.matches?(line)).to be_falsey
+    end
+
+    it 'apply the name to the last event on the stack' do
+      line = '* FROM CLIP NAME:  TAPE_6-10.MOV'
+
+      mok_evt = double
+      comments = []
+      expect(mok_evt).to receive(:clip_name=).with('TAPE_6-10.MOV')
+      expect(mok_evt).to receive(:comments).and_return(comments)
+
+      EDL::NameMatcher.new.apply([mok_evt], line)
+      expect(['* FROM CLIP NAME:  TAPE_6-10.MOV']).to eq comments
+    end
+  end
+
+  describe 'EffectMatcher' do
+    it 'not match a simple comment' do
+      line = '* STUFF'
+      expect(EDL::EffectMatcher.new.matches?(line)).to be_falsey
+    end
+
+    it 'match a dissolve name' do
+      line = '* EFFECT NAME: CROSS DISSOLVE'
+      expect(EDL::EffectMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'match a dissolve name without space after the asterisk' do
+      line = '*EFFECT NAME: CROSS DISSOLVE'
+      expect(EDL::EffectMatcher.new.matches?(line)).to be_truthy
+    end
+    
+    it 'match a dissolve name containing an asterisk' do
+      line = '* EFFECT NAME: *CROSS DISSOLVE'
+      expect(EDL::EffectMatcher.new.matches?(line)).to be_truthy
+    end
+
+    it 'apply the effect name to the transition of the last event on the stack' do
+      line = '* EFFECT NAME: CROSS DISSOLVE'
+      mok_evt = double
+      mok_transition = double
+      cmt = []
+
+      expect(mok_evt).to receive(:transition).and_return(mok_transition)
+      expect(mok_evt).to receive(:comments).and_return(cmt)
+
+      expect(mok_transition).to receive(:effect=).with('CROSS DISSOLVE')
+
+      EDL::EffectMatcher.new.apply([mok_evt], line)
+
+      expect(['* EFFECT NAME: CROSS DISSOLVE']).to eq cmt
+    end
+  end
+
+  describe 'An EDL with mixed line breaks' do
+    it 'parse without errors' do
+      list = EDL::Parser.new.parse(File.open(MIXED_LINEBREAKS))
+      expect(['* A', '* B', '* C', '* D', '* E', '* F', '* G']).to eq list[0].comments
+    end
+  end
+
+  describe 'A complex EDL passed via Parser' do
+    it 'parse without errors' do
+      expect { EDL::Parser.new.parse(File.open(FORTY_FIVER)) }.to_not raise_error
+    end
+
+    it 'parse the EDL with \\r line breaks properly' do
+      evts = EDL::Parser.new.parse(File.read(PLATES))
+      expect(3).to eq evts.length
+    end
+
+    # TODO: this does not belong here
+    it 'be properly rewritten from zero' do
+      complex = EDL::Parser.new.parse(File.open(FORTY_FIVER))
+      from_zero = complex.from_zero
+
+      expect(complex.length).to eq(from_zero.length), 'Should have the same number of events'
+
+      expect(from_zero[0].rec_start_tc).to be_zero
+      expect('00:00:42:16'.tc).to eq from_zero[-1].rec_end_tc
+    end
+  end
+
+  describe 'A FinalCutPro speedup with fade at the end' do
+    it 'be parsed cleanly' do
+      list = EDL::Parser.new.parse(File.open(SPEEDUP_AND_FADEOUT))
+
+      expect(2).to eq list.length
+
+      first_evt = list[0]
+
+      tw = first_evt.timewarp
+      expect(tw).to be_a(EDL::Timewarp)
+
+      expect(689).to eq first_evt.rec_length
+      expect(714).to eq first_evt.rec_length_with_transition
+
+      expect(1000).to eq tw.actual_length_of_source
+      expect(140).to eq tw.speed
+
+      expect(1000).to eq first_evt.src_length
+
+      expect('01:00:00:00').to eq first_evt.capture_from_tc.to_s
+      expect('01:00:40:00').to eq first_evt.capture_to_tc.to_s
+    end
+  end
+
+  describe 'In the trailer EDL the event 4' do
+    it 'not have too many comments' do
+      evts = EDL::Parser.new.parse(File.open(TRAILER_EDL))
+      evt = evts[6]
+      expect(5).to eq evt.comments.length
+    end
+  end
+
+  describe 'A FinalCutPro speedup and reverse with fade at the end' do
+    it 'parse cleanly' do
+      first_evt = EDL::Parser.new.parse(File.open(SPEEDUP_REVERSE_AND_FADEOUT)).shift
+
+      expect(first_evt).to be_reverse
+
+      expect(689).to eq first_evt.rec_length
+      expect(714).to eq first_evt.rec_length_with_transition
+
+      tw = first_evt.timewarp
+
+      expect('1h 1f'.tc).to eq tw.source_used_from
+      expect('1h 40s'.tc).to eq tw.source_used_upto
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'edl'
+
+RSpec.configure do |config|
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: edl
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Julik Tarkhanov
+- Philipp Großelfinger
 autorequire: 
 bindir: exe
 cert_chain: []
@@ -57,16 +58,16 @@ email: me@julik.nl
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
 - ".gitignore"
 - ".rspec"
 - ".ruby-gemset"
-- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - History.txt
-- README.rdoc
+- LICENSE.txt
+- README.md
 - Rakefile
 - edl.gemspec
 - illustr/edl-explain.ai
@@ -79,9 +80,27 @@ files:
 - lib/edl/timewarp.rb
 - lib/edl/transition.rb
 - lib/edl/version.rb
+- spec/fixtures/files/45S_SAMPLE.EDL
+- spec/fixtures/files/FCP_REVERSE.EDL
+- spec/fixtures/files/KEY_TRANSITION.EDL
+- spec/fixtures/files/PLATES.EDL
+- spec/fixtures/files/REEL_IS_CLIP.txt
+- spec/fixtures/files/REVERSE.EDL
+- spec/fixtures/files/SIMPLE_DISSOLVE.EDL
+- spec/fixtures/files/SPEEDUP_AND_FADEOUT.EDL
+- spec/fixtures/files/SPEEDUP_REVERSE_AND_FADEOUT.EDL
+- spec/fixtures/files/SPLICEME.EDL
+- spec/fixtures/files/TIMEWARP.EDL
+- spec/fixtures/files/TIMEWARP_HALF.EDL
+- spec/fixtures/files/TRAILER_EDL.edl
+- spec/fixtures/files/edl_mixed_line_endings.edl
+- spec/lib/edl/parser_spec.rb
+- spec/lib/edl_spec.rb
+- spec/spec_helper.rb
 homepage: http://guerilla-di.org/edl
 licenses: []
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -95,10 +114,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.2.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.4.5.2
 signing_key: 
 specification_version: 4
 summary: Parser for EDL (Edit Decision List) files

data/.ruby-version

@@ -1 +0,0 @@
-2.4.1