julik-edl 0.0.8

data/lib/edl/grabber.rb

@@ -0,0 +1,29 @@
+module EDL
+  # When initialized with a file and passed an EDL, will generate thumbnail images
+  # of the first frame of every event. It is assumed that the movie file starts at the same
+  # frame as the first EDL event.
+  class Grabber #:nodoc:
+    attr_accessor :ffmpeg_bin, :offset
+    def initialize(with_file)
+      @source_path = with_file
+    end
+    
+    def ffmpeg_bin
+      @ffmpeg_bin || 'ffmpeg'
+    end
+    
+    def grab(edl)
+      edl.from_zero.events.each do | evt |
+        grab_frame_tc = evt.rec_start_tc + (offset || 0 )
+        
+        to_file = File.dirname(@source_path) + '/' + evt.num + '_' + File.basename(@source_path).gsub(/\.(\w+)$/, '')
+        generate_grab(evt.num, grab_frame_tc, to_file)
+      end
+    end
+    
+    def generate_grab(evt, at, to_file)
+      cmd = "#{ffmpeg_bin} -i #{@source_path} -an -ss #{at.with_frames_as_fraction} -vframes 1 -y #{to_file}%d.jpg"
+      `#{cmd}`
+    end
+  end
+end

data/lib/edl/timewarp.rb

@@ -0,0 +1,45 @@
+module EDL
+  # Represents a timewarp. Will be placed in EDL::Event#timewarp
+  # For a reversed clip, the source start we get from the EDL in the src start
+  # is the LAST used frame. For a pos rate clip, the source start is the bona fide source start. Nice eh? 
+  class Timewarp
+  
+    # What is the actual framerate of the clip (float)
+    attr_accessor :actual_framerate
+    attr_accessor :clip #:nodoc:
+    
+    # Does this timewarp reverse the clip?
+    def reverse?
+      @actual_framerate < 0
+    end
+    
+    # Get the speed in percent
+    def speed_in_percent
+      (@actual_framerate / @clip.rec_start_tc.fps) * 100
+    end
+    alias_method :speed, :speed_in_percent
+    
+    # Compute the length of the clip we need to capture. The length is computed in frames and
+    # is always rounded up (better one frame more than one frame less!)
+    def actual_length_of_source
+      # First, get the length of the clip including a transition. This is what we are scaled to.
+      target_len = @clip.rec_length_with_transition.to_f
+      # Determine the framerate scaling factor, this is the speed
+      factor = @actual_framerate / @clip.rec_start_tc.fps
+      (target_len * factor).ceil.abs
+    end
+    
+    # What is the starting frame for the captured clip? If we are a reverse, then the src start of the
+    # clip is our LAST frame, otherwise it's the first
+    def source_used_from
+      # TODO: account for the 2 frame deficiency which is suspicious
+      compensation = 2
+      reverse? ? (@clip.src_start_tc - actual_length_of_source + compensation) : @clip.src_start_tc
+    end
+    
+    # Where to end the capture? This is also dependent on whether we are a reverse or not
+    def source_used_upto
+      source_used_from + actual_length_of_source
+    end
+  end
+end

data/lib/edl/transition.rb

@@ -0,0 +1,23 @@
+module EDL
+  # Represents a transition. We currently only support dissolves and SMPTE wipes
+  # Will be avilable as EDL::Clip#transition
+  class Transition
+  
+    # Length of the transition in frames
+    attr_accessor :duration
+    
+    # Which effect is used (like CROSS DISSOLVE)
+    attr_accessor :effect
+  end
+
+  # Represents a dissolve
+  class Dissolve < Transition
+  end
+
+  # Represents an SMPTE wipe
+  class Wipe < Transition
+    
+    # Which SMPTE wipe is needed
+    attr_accessor :smpte_wipe_index
+  end
+end

data/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/samples/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/test/test_edl.rb

@@ -0,0 +1,664 @@
+require File.dirname(__FILE__) + '/../lib/edl'
+require File.dirname(__FILE__) + '/../lib/edl/cutter'
+require File.dirname(__FILE__) + '/../lib/edl/grabber'
+
+require 'rubygems'
+require 'test/unit'
+require 'test/spec'
+require 'flexmock'
+require 'flexmock/test_unit'
+
+TRAILER_EDL                 = File.dirname(__FILE__) + '/samples/TRAILER_EDL.edl'
+SIMPLE_DISSOLVE             = File.dirname(__FILE__) + '/samples/SIMPLE_DISSOLVE.EDL'
+SPLICEME                    = File.dirname(__FILE__) + '/samples/SPLICEME.EDL'
+SIMPLE_TIMEWARP             = File.dirname(__FILE__) + '/samples/TIMEWARP.EDL'
+SLOMO_TIMEWARP              = File.dirname(__FILE__) + '/samples/TIMEWARP_HALF.EDL'
+FORTY_FIVER                 = File.dirname(__FILE__) + '/samples/45S_SAMPLE.EDL'
+AVID_REVERSE                = File.dirname(__FILE__) + '/samples/REVERSE.EDL'
+SPEEDUP_AND_FADEOUT         = File.dirname(__FILE__) + '/samples/SPEEDUP_AND_FADEOUT.EDL'
+SPEEDUP_REVERSE_AND_FADEOUT = File.dirname(__FILE__) + '/samples/SPEEDUP_REVERSE_AND_FADEOUT.EDL'
+FCP_REVERSE                 = File.dirname(__FILE__) + '/samples/FCP_REVERSE.EDL'
+
+class String
+  def tc(fps = Timecode::DEFAULT_FPS)
+    Timecode.parse(self, fps)
+  end
+end
+
+context "An Event should" do
+  specify "define the needed attributes" do
+    evt = EDL::Event.new
+    %w(  num reel track src_start_tc src_end_tc rec_start_tc rec_end_tc ).each do | em |
+      evt.should.respond_to em
+    end
+  end
+  
+  specify "support hash initialization" do
+    evt = EDL::Event.new(:src_start_tc => "01:00:00:00".tc)
+    evt.src_start_tc.should.equal "01:00:00:00".tc
+  end
+
+  specify "support block initialization" do
+    evt = EDL::Event.new do | e | 
+      e.src_start_tc = "01:00:00:04".tc
+    end
+    evt.src_start_tc.should.equal "01:00:00:04".tc
+  end
+
+  specify "respond to ends_with_transition? with false if outgoing_transition_duration is zero" do
+    evt = EDL::Event.new
+    evt.outgoing_transition_duration = 0
+    evt.ends_with_transition?.should.equal false
+  end
+  
+  specify "respond to ends_with_transition? with true if outgoing_transition_duration set above zero" do
+    evt = EDL::Event.new
+    evt.outgoing_transition_duration = 24
+    evt.ends_with_transition?.should.equal true
+  end
+  
+  specify "respond to has_timewarp? with false if no timewarp assigned" do
+    evt = EDL::Event.new(:timewarp => nil)
+    evt.has_timewarp?.should.equal false
+  end
+
+  specify "respond to has_timewarp? with true if a timewarp  is assigned" do
+    evt = EDL::Event.new(:timewarp => true)
+    evt.has_timewarp?.should.equal true
+  end
+  
+  specify "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 )
+    evt.rec_length.should.equal "10s 2f".tc.to_i
+  end
+
+  specify "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)
+    evt.rec_length_with_transition.should.equal "10s 2f".tc.to_i
+  end
+
+  specify "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)
+    evt.rec_length_with_transition.should.equal("10s 2f".tc.to_i + 10)
+  end
+
+  specify "return a default array for comments" do
+    EDL::Event.new.comments.should.be.kind_of Enumerable
+  end
+
+  specify "respond false to has_transition? if incoming transition is set" do
+    EDL::Event.new(:transition => nil).has_transition?.should.equal false
+  end
+
+  specify "respond true to has_transition? if incoming transition is set" do
+    EDL::Event.new(:transition => true).has_transition?.should.equal true
+  end
+  
+  specify "respond true to black? if reel is BL" do
+    EDL::Event.new(:reel => "BL").should.black
+    EDL::Event.new(:reel => "001").should.not.black
+  end
+
+  specify "respond true to generator? if reel is BL or AX" do
+    EDL::Event.new(:reel => "BL").should.generator
+    EDL::Event.new(:reel => "AX").should.generator
+    EDL::Event.new(:reel => "001").should.not.generator
+  end
+  
+  specify "report src_length as rec_length_with_transition" do
+    e = EDL::Event.new(:rec_start_tc => "2h".tc,  :rec_end_tc => "2h 2s".tc)
+    e.src_length.should.equal "2s".tc.to_i 
+  end
+  
+  specify "support line_number" do
+    EDL::Event.new.line_number.should.be.nil
+    EDL::Event.new(:line_number => 3).line_number.should.equal 3
+  end
+  
+  specify "support capture_length as an alias to src_length" do
+    tw = flexmock
+    tw.should_receive(:actual_length_of_source).and_return(:something)
+    e = EDL::Event.new(:timewarp => tw)
+    e.src_length.should.equal e.capture_length
+  end
+  
+  specify "delegate src_length to the timewarp if it is there" do
+    tw = flexmock
+    tw.should_receive(:actual_length_of_source).and_return(:something).once
+    e = EDL::Event.new(:timewarp => tw)
+    e.src_length.should.equal :something 
+  end
+  
+  specify "report reverse? and reversed? based on the timewarp" do
+    e = EDL::Event.new(:timewarp => nil)
+    e.should.not.be.reverse
+    e.should.not.be.reversed
+
+    tw = flexmock
+    tw.should_receive(:reverse?).and_return(true)
+
+    e = EDL::Event.new(:timewarp => tw)
+    e.should.be.reverse
+    e.should.be.reversed
+  end
+  
+  specify "report speed as 100 percent without a timewarp" do
+    e = EDL::Event.new
+    e.speed.should.be.kind_of Float
+    e.speed.should.equal 100.0
+  end
+
+  specify "consult the timewarp for speed" do
+    tw = flexmock
+    tw.should_receive(:speed).and_return(:something)
+
+    e = EDL::Event.new(:timewarp => tw)
+    e.speed.should.equal :something
+  end
+
+  specify "report false for starts_with_transition? if transision is nil" do
+    e = EDL::Event.new
+    e.should.respond_to :starts_with_transition?
+    e.should.not.be.starts_with_transition
+  end
+
+  specify "report zero for incoming_transition_duration if transision is nil" do
+    e = EDL::Event.new
+    e.should.respond_to :incoming_transition_duration
+    e.incoming_transition_duration.should.zero
+  end
+
+  specify "report true for starts_with_transition? if transision is not nil" do
+    e = EDL::Event.new :transition => true
+    e.should.respond_to :starts_with_transition?
+    e.should.starts_with_transition
+  end
+
+  specify "consult the transition for incoming_transition_duration if it's present" do
+    tr = flexmock
+    tr.should_receive(:duration).and_return(:something)
+    
+    e = EDL::Event.new(:transition => tr)
+    e.should.respond_to :incoming_transition_duration
+    e.incoming_transition_duration.should.equal :something
+  end
+  
+  specify "report capture_from_tc as the source start without a timewarp" do
+    e = EDL::Event.new(:src_start_tc => "1h".tc)
+    e.capture_from_tc.should.equal "1h".tc
+  end
+  
+  specify "consult the timewarp for capture_from_tc if a timewarp is there" do
+    tw = flexmock
+    tw.should_receive(:source_used_from).and_return(:something)
+    
+    e = EDL::Event.new(:timewarp => tw)
+    e.capture_from_tc.should.equal :something
+  end
+
+  specify "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 )
+    e.capture_to_tc.should.equal "1h 10s 2f".tc
+  end
+
+  specify "consult the timewarp for capture_to_tc if timewarp is present" do
+    tw = flexmock
+    tw.should_receive(:source_used_upto).and_return(:something)
+
+    e = EDL::Event.new(:timewarp => tw)
+    e.capture_to_tc.should.equal :something
+  end
+
+
+end
+
+context "A Parser should" do
+  
+  specify "store the passed framerate" do
+    p = EDL::Parser.new(45)
+    p.should.respond_to :fps
+    p.fps.should.equal 45
+  end
+  
+  specify "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) }
+    event_matcher.fps.should.equal 30
+  end
+  
+  specify "create a Timecode from stringified elements" do
+    elems = ["08", "04", "24", "24"]
+    lambda{ @tc = EDL::Parser.timecode_from_line_elements(elems, 30) }.should.not.raise
+    
+    @tc.should.be.kind_of Timecode
+    @tc.should.equal "08:04:24:24".tc(30)
+    
+    elems.length.should.equal 0
+  end
+  
+  specify "parse from a String" do
+    p = EDL::Parser.new
+    lambda{ @edl = p.parse File.read(SIMPLE_DISSOLVE) }.should.not.raise
+    
+    @edl.should.be.kind_of EDL::List
+    @edl.length.should.equal 2
+  end
+
+  specify "parse from a File/IOish" do
+    p = EDL::Parser.new
+    lambda{ @edl = p.parse File.open(SIMPLE_DISSOLVE) }.should.not.raise
+    
+    @edl.should.be.kind_of EDL::List
+    @edl.length.should.equal 2
+  end
+    
+  specify "properly parse a dissolve" do
+    # TODO: reformulate
+    p = EDL::Parser.new
+    lambda{ @edl = p.parse File.open(SIMPLE_DISSOLVE) }.should.not.raise
+
+    @edl.should.be.kind_of EDL::List
+    @edl.length.should.equal 2
+    
+    first, second = @edl
+    first.should.be.kind_of EDL::Event
+    second.should.be.kind_of EDL::Event
+    
+    second.has_transition?.should.equal true
+    first.ends_with_transition?.should.equal true
+    second.ends_with_transition?.should.equal false
+    
+    no_trans = @edl.without_transitions
+    
+    assert_equal 2, no_trans.length
+    target_tc = (Timecode.parse('01:00:00:00') + 43)
+    assert_equal target_tc, no_trans[0].rec_end_tc, 
+      "The incoming clip should have been extended by the length of the dissolve"
+    
+    target_tc = Timecode.parse('01:00:00:00')
+    assert_equal target_tc, no_trans[1].rec_start_tc
+      "The outgoing clip should have been left in place"
+  end
+  
+  specify "return a spliced EDL if the sources allow" do
+    lambda{ @spliced = EDL::Parser.new.parse(File.open(SPLICEME)).spliced }.should.not.raise
+
+    @spliced.length.should.equal 1
+    @spliced[0].src_start_tc.should.equal '06:42:50:18'.tc
+    @spliced[0].src_end_tc.should.equal   '06:42:52:16'.tc
+  end
+  
+  specify "not apply any Matchers if a match is found" do
+    p = EDL::Parser.new
+    m1 = flexmock
+    m1.should_receive(:matches?).with("plop").once.and_return(true)
+    m1.should_receive(:apply).once
+    
+    flexmock(p).should_receive(:get_matchers).once.and_return([m1, m1])
+    result = p.parse("plop")
+    result.should.be.empty
+  end
+  
+  specify "register line numbers of the detected events" do
+    p = EDL::Parser.new
+    events = p.parse(File.open(SPLICEME))
+    
+    events[0].line_number.should.not.be.nil
+    events[0].line_number.should.equal 4
+    
+    events[1].line_number.should.not.be.nil
+    events[1].line_number.should.equal 5
+  end
+end
+
+context "A TimewarpMatcher should" do
+  
+  specify "not create any extra events when used within a Parser" do
+    @edl = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP))
+    @edl.length.should.equal 1
+  end
+
+  specify "properly describe a speedup" do
+    clip = EDL::Parser.new.parse(File.open(SIMPLE_TIMEWARP)).pop
+    
+    tw = clip.timewarp
+    
+    tw.should.be.kind_of EDL::Timewarp
+    tw.source_used_upto.should.be > clip.src_end_tc
+
+    tw.source_used_from.should.equal clip.src_start_tc
+    clip.timewarp.actual_length_of_source.should.equal 124
+    
+    tw.reverse?.should.be false
+  end
+  
+  specify "properly describe a slomo" do
+    clip = EDL::Parser.new.parse(File.open(SLOMO_TIMEWARP)).pop
+
+    clip.rec_length.should.equal 10
+    clip.src_length.should.equal 5
+    
+    tw = clip.timewarp
+    tw.should.be.kind_of EDL::Timewarp
+
+    tw.source_used_upto.should.be < clip.src_end_tc
+    tw.source_used_upto.should.equal "03:03:19:24".tc
+    tw.speed_in_percent.to_i.should.equal 50
+    tw.actual_length_of_source.should.equal 5
+    
+    tw.should.not.be.reverse
+  end
+
+end
+
+context "A reverse timewarp EDL coming from Avid should" do
+  
+  specify "be parsed properly" do
+    
+    clip = EDL::Parser.new.parse(File.open(AVID_REVERSE)).pop
+    
+    clip.rec_length.should.equal 52
+    
+    tw = clip.timewarp
+    tw.actual_framerate.to_i.should.equal -25
+    
+    tw.should.be.reverse
+    
+    tw.actual_length_of_source.should.equal 52
+    
+    assert_equal 52, clip.src_length, "The src length should be computed the same as its just a reverse"
+    assert_equal -100.0, clip.timewarp.speed
+  end
+end
+
+context "A Final Cut Pro originating reverse should" do
+  
+  specify "be interpreted properly" do
+    e = EDL::Parser.new.parse(File.open(FCP_REVERSE)).pop
+    
+    e.rec_length.should.equal 1000
+    e.src_length.should.equal 1000
+
+    e.rec_start_tc.should.equal "1h".tc
+    e.rec_end_tc.should.equal "1h 40s".tc
+    
+    e.should.be.reverse
+    e.timewarp.should.not.be nil
+    
+    tw = e.timewarp
+    
+    tw.speed.should.equal -100.0
+    e.speed.should.equal  -100.0
+    
+    tw.source_used_from.should.equal "1h".tc
+    tw.source_used_upto.should.equal "1h 40s".tc
+  end
+end
+
+context "EventMatcher should" 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',
+  ]
+
+  specify "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'
+    )
+    
+    clip.should.be.kind_of EDL::Event
+    
+    clip.num.should.equal "020"
+    clip.reel.should.equal "008C"
+    clip.track.should.equal "V"
+    
+    clip.src_start_tc.should.equal '08:04:24:24'.tc
+    
+    clip.src_end_tc.should.equal   '08:04:25:19'.tc
+    clip.rec_start_tc.should.equal '01:00:25:22'.tc
+    clip.rec_end_tc.should.equal   '01:00:26:17'.tc
+    
+    clip.transition.should.be nil
+    clip.timewarp.should.be nil
+    clip.outgoing_transition_duration.should.be.zero
+    
+  end
+  
+  specify "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'
+    )
+    dissolve.should.be.kind_of EDL::Event
+    
+    dissolve.num.should.equal "025"
+    dissolve.reel.should.equal "GEN"
+    dissolve.track.should.equal "V"
+    
+    dissolve.should.be.has_transition
+    
+    tr = dissolve.transition
+    
+    tr.should.be.kind_of EDL::Dissolve
+    tr.duration.should.equal 25
+  end
+  
+  specify "set flag on the previous event in the stack when a dissolve is encountered" do
+    m = EDL::EventMatcher.new(25)
+    previous_evt = flexmock
+    previous_evt.should_receive(:outgoing_transition_duration=).with(25).once
+    
+    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
+
+  specify "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
+    tr.should.be.kind_of EDL::Wipe
+    tr.duration.should.equal 25
+    tr.smpte_wipe_index.should.equal '001'
+  end
+  
+  specify "match the widest range of patterns" do
+    EVT_PATTERNS.each do | pat |
+      assert EDL::EventMatcher.new(25).matches?(pat), "EventMatcher should match #{pat}"
+    end
+  end
+  
+  specify "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'
+    )
+    clip.rec_start_tc.fps.should.equal 30
+    clip.rec_end_tc.fps.should.equal 30
+    clip.src_start_tc.fps.should.equal 30
+    clip.src_end_tc.fps.should.equal 30
+  end
+end
+
+context "CommentMatcher should" do
+  specify "match a comment" do
+    line = "* COMMENT: PURE BULLSHIT"
+    assert EDL::CommentMatcher.new.matches?(line)
+  end
+  
+  specify "apply the comment to the last clip on the stack" do
+    line = "* COMMENT: PURE BULLSHIT"
+
+    comments = []
+    mok_evt = flexmock
+
+    2.times { mok_evt.should_receive(:comments).and_return(comments) }
+    2.times { EDL::CommentMatcher.new.apply([mok_evt], line) }
+
+    mok_evt.comments.should.equal ["* COMMENT: PURE BULLSHIT", "* COMMENT: PURE BULLSHIT"] 
+  end
+end
+
+context "FallbackMatcher should" do
+  specify "match anything" do
+    line = "SOME"
+    EDL::FallbackMatcher.new.matches?(line).should.equal true
+
+    line = "OR ANOTHER  "
+    EDL::FallbackMatcher.new.matches?(line).should.equal true
+  end
+  
+  specify "not match whitespace" do
+    line = "\s\s\s\r\n\r"
+    EDL::FallbackMatcher.new.matches?(line).should.equal false
+  end
+  
+  specify "append the matched content to comments" do
+    e = flexmock
+    cmts = []
+    e.should_receive(:comments).and_return(cmts)
+    
+    EDL::FallbackMatcher.new.apply([e], "FOOBAR")
+    cmts.should.equal ["FOOBAR"]
+
+    EDL::FallbackMatcher.new.apply([e], "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I")
+    cmts.should.equal ["FOOBAR", "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I"]
+  end
+  
+  specify "raise an ApplyError if no clip is on the stack" do
+    lambda { EDL::FallbackMatcher.new.apply([], "FINAL CUT PRO REEL: 006-I REPLACED BY: 006I") }.should.raise(EDL::Matcher::ApplyError)
+  end
+  
+end
+
+context "ClipNameMatcher should" do
+  specify "match a clip name" do
+    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
+    EDL::NameMatcher.new.matches?(line).should.equal true
+  end
+  
+  specify "not match a simple comment" do
+    line = "* CRAP"
+    EDL::NameMatcher.new.matches?(line).should.equal false
+  end
+  
+  specify "apply the name to the last event on the stack" do
+    line = "* FROM CLIP NAME:  TAPE_6-10.MOV"
+
+    mok_evt = flexmock
+    comments = []
+    mok_evt.should_receive(:clip_name=).with('TAPE_6-10.MOV').once
+    mok_evt.should_receive(:comments).and_return(comments).once
+    
+    EDL::NameMatcher.new.apply([mok_evt], line)
+    comments.should.equal ["* FROM CLIP NAME:  TAPE_6-10.MOV"] 
+  end
+  
+end
+
+context "EffectMatcher should" do
+  specify "not match a simple comment" do
+    line = "* STUFF"
+    EDL::EffectMatcher.new.matches?(line).should.equal false
+  end
+
+  specify "match a dissolve name" do
+    line = "* EFFECT NAME: CROSS DISSOLVE"
+    EDL::EffectMatcher.new.matches?(line).should.equal true
+  end
+
+  specify "apply the effect name to the transition of the last event on the stack" do
+    line = "* EFFECT NAME: CROSS DISSOLVE"
+    mok_evt, mok_transition = flexmock, flexmock
+    cmt = []
+    
+    mok_evt.should_receive(:transition).once.and_return(mok_transition)
+    mok_evt.should_receive(:comments).once.and_return(cmt)
+
+    mok_transition.should_receive(:effect=).with("CROSS DISSOLVE").once
+    
+    EDL::EffectMatcher.new.apply([mok_evt], line)
+    
+    cmt.should.equal ["* EFFECT NAME: CROSS DISSOLVE"]
+  end
+
+end
+
+context "A complex EDL passed via Parser should" do
+  specify "parse without errors" do
+    assert_nothing_raised { EDL::Parser.new.parse(File.open(FORTY_FIVER)) }
+  end
+  
+  # TODO: this does not belong here
+  specify "be properly rewritten from zero" do
+    complex = EDL::Parser.new.parse(File.open(FORTY_FIVER))
+    from_zero = complex.from_zero
+    
+    # Should have the same number of events
+    from_zero.length.should.equal complex.length
+    
+    from_zero[0].rec_start_tc.should.be.zero
+    from_zero[-1].rec_end_tc.should.equal '00:00:42:16'.tc
+  end
+end
+
+context "A FinalCutPro speedup with fade at the end should" do
+  specify "be parsed cleanly" do
+    list = EDL::Parser.new.parse(File.open(SPEEDUP_AND_FADEOUT))
+    
+    list.length.should.equal 2
+    
+    first_evt = list[0]
+    
+    tw = first_evt.timewarp
+    tw.should.be.kind_of EDL::Timewarp
+    
+    first_evt.rec_length.should.equal 689
+    first_evt.rec_length_with_transition.should.equal 714
+    
+    tw.actual_length_of_source.should.equal 1000
+    tw.speed.should.equal 140
+    
+    assert_equal 1000, first_evt.src_length
+    
+    assert_equal "01:00:00:00", first_evt.capture_from_tc.to_s
+    assert_equal "01:00:40:00", first_evt.capture_to_tc.to_s
+  end
+end
+
+context "In the trailer EDL the event 4 should" do
+  specify "not have too many comments" do
+    evts = EDL::Parser.new.parse(File.open(TRAILER_EDL))
+    evt = evts[6]
+    evt.comments.length.should.equal(5)
+  end
+end
+
+context "A FinalCutPro speedup and reverse with fade at the end should" do
+  specify "parse cleanly" do
+    first_evt = EDL::Parser.new.parse(File.open(SPEEDUP_REVERSE_AND_FADEOUT)).shift
+    
+    first_evt.should.be.reverse
+    
+    first_evt.rec_length.should.equal 689
+    first_evt.rec_length_with_transition.should.equal 714 
+    
+    tw = first_evt.timewarp
+    tw.source_used_from.should.equal "1h 1f".tc
+    tw.source_used_upto.should.equal "1h 40s".tc
+  end
+end