timecode 0.1.3 → 0.1.4

data/History.txt

@@ -1,6 +1,11 @@
+=== 0.1.4 / 2000-01-01
+
+* Expanded test coverage
+* Some formatting/doc improvements
+
 === 0.1.3 / 2008-12-25
 
-* Implement the format FFmpeg uses
+* Implement the format FFmpeg uses (fractional seconds instead of frames)
 
 === 0.1.2 / 2008-12-25
 

data/lib/timecode.rb

@@ -12,13 +12,15 @@
 #     :mapping => [%w(source_tc_frames total), %w(tape_fps fps)]
 
 class Timecode
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 
   include Comparable
   
   DEFAULT_FPS = 25.0
   ALLOWED_FPS_DELTA = 0.001
   COMPLETE_TC_RE = /^(\d{1,2}):(\d{1,2}):(\d{1,2}):(\d{1,2})$/
+  WITH_FRACTIONS_OF_SECOND = "%02d:%02d:%02d.%02d"
+  WITH_FRAMES = "%02d:%02d:%02d:%02d"
   
   # All Timecode lib errors inherit from this
   class Error < RuntimeError; end
@@ -44,19 +46,9 @@ class Timecode
   # Well well...
   class MethodRequiresTimecode < ArgumentError; end
   
-  # Initialize a new Timecode. If a string is passed, it will be parsed, an integer
+  # Initialize a new Timecode object with a certain amount of frames and a framerate
   # will be interpreted as the total number of frames
-  def self.new(total_or_string = 0, fps = DEFAULT_FPS)
-    if total_or_string.nil?
-      new(0, fps)
-    elsif total_or_string.is_a?(String)
-      parse(total_or_string, fps)
-    else
-      super(total_or_string, fps)
-    end
-  end
-  
-  def initialize(total = 0, fps = DEFAULT_FPS) # :nodoc:
+  def initialize(total = 0, fps = DEFAULT_FPS)
     raise RangeError, "Timecode cannot be negative" if total.to_f < 0
     raise WrongFramerate, "FPS cannot be zero" if fps.zero?
 
@@ -188,7 +180,7 @@ class Timecode
     to_f
   end
   
-  #get FPS
+  # get FPS
   def fps
     @fps
   end
@@ -231,16 +223,13 @@ class Timecode
   # Convert to different framerate based on the total frames. Therefore,
   # 1 second of PAL video will convert to 25 frames of NTSC (this 
   # is suitable for PAL to film TC conversions and back).
-  # It does not account for pulldown or anything in that sense, because
-  # then you need to think about cadences and such
   def convert(new_fps)
-    raise NonPositiveFps, "FPS cannot be less than 0" if new_fps < 1
-    self.class.new((total/fps)*new_fps, new_fps)
+    self.class.new(@total, new_fps)
   end
   
   # get formatted SMPTE timecode
   def to_s
-    "%02d:%02d:%02d:%02d" % value_parts
+    WITH_FRAMES % value_parts
   end
   
   # get total frames as float
@@ -286,9 +275,10 @@ class Timecode
     self.class.new(@total + 1, @fps)
   end
   
-  # Slice the timespan in pieces
+  # Get the number of times a passed timecode fits into this time span (if performed with Timecode) or 
+  # a Timecode that multiplied by arg will give this one
   def /(arg)
-    Timecode.new(@total/arg, @fps)
+    arg.is_a?(Timecode) ?  (@total / arg.total) : Timecode.new(@total /arg, @fps)
   end
   
   # Timecodes can be compared to each other
@@ -307,7 +297,7 @@ class Timecode
   def with_frames_as_fraction
     vp = value_parts.dup
     vp[-1] = (100.0 / @fps) * vp[-1]
-    "%02d:%02d:%02d.%02d" % vp
+    WITH_FRACTIONS_OF_SECOND % vp
   end
   alias_method :with_fractional_seconds, :with_frames_as_fraction
   

data/test/test_timecode.rb

@@ -1,9 +1,6 @@
 require 'test/unit'
-require 'rubygems'
-require 'timecode'
+require File.dirname(__FILE__) + '/../lib/timecode'
 
-# for Fixnum#hours
-require 'active_support'
 
 class TimecodeTest < Test::Unit::TestCase
   
@@ -29,6 +26,10 @@ class TimecodeTest < Test::Unit::TestCase
     assert t1 == t2
   end
   
+  def test_to_i_is_total
+    assert_equal 10, Timecode.new(10).to_i
+  end
+  
   def test_inspect
     tc = Timecode.new(10, 25)
     assert_equal "#<Timecode:00:00:00:10 (10F@25.00)>", tc.inspect
@@ -39,7 +40,8 @@ class TimecodeTest < Test::Unit::TestCase
   end
   
   def test_basics
-    five_seconds_of_pal = 5.seconds * 25
+    five_seconds_of_pal = 5 * 25
+
     tc = Timecode.new(five_seconds_of_pal, 25)
     assert_equal 0, tc.hours
     assert_equal 0, tc.minutes
@@ -48,7 +50,7 @@ class TimecodeTest < Test::Unit::TestCase
     assert_equal five_seconds_of_pal, tc.total
     assert_equal "00:00:05:00", tc.to_s
     
-    one_and_a_half_hour_of_hollywood = 90.minutes * 24
+    one_and_a_half_hour_of_hollywood = (90 * 60) * 24
 
     film_tc = Timecode.new(one_and_a_half_hour_of_hollywood, 24)
     assert_equal 1, film_tc.hours
@@ -65,7 +67,7 @@ class TimecodeTest < Test::Unit::TestCase
       tc + film_tc
     end
     
-    two_seconds_and_five_frames_of_pal = ((2.seconds * 25) + 5)
+    two_seconds_and_five_frames_of_pal = ((2 * 25) + 5)
     pal_tc = Timecode.new(two_seconds_and_five_frames_of_pal, 25)
     assert_nothing_raised do
       added_tc = pal_tc + tc
@@ -80,15 +82,81 @@ class TimecodeTest < Test::Unit::TestCase
   
   def test_zero
     assert Timecode.new(0).zero?
+    assert Timecode.parse("00:00:00:00").zero?
     assert !Timecode.new(1).zero?
     assert !Timecode.new(1000).zero?
   end
   
+  def test_timecode_rangeable
+    r = Timecode.new(10)...Timecode.new(20)
+    assert_equal 10, r.to_a.length
+    assert_equal Timecode.new(14), r.to_a[4]
+  end
+  
+  def test_frame_interval
+    tc = Timecode.new(10)
+    assert_in_delta tc.frame_interval, 0.04, 0.0001
+
+    tc = Timecode.new(10, 30)
+    assert_in_delta tc.frame_interval, 0.03333, 0.0001
+  end
+end
+
+class ConversionTest < Test::Unit::TestCase
+  def test_convert_25_at_24
+    tc = Timecode.new(40, 25)
+    at24 = tc.convert(24)
+    assert_equal tc.total, at24.total
+  end
+end
+
+class CalculationsTest < Test::Unit::TestCase
   def test_plus
     a, b = Timecode.new(24, 25.000000000000001), Timecode.new(22, 25.000000000000002)
     assert_equal Timecode.new(24 + 22, 25.000000000000001), (a + b)
   end
   
+  def test_plus_with_different_framerates_should_raise
+    assert_raise(Timecode::WrongFramerate) { Timecode.new(10, 25) + Timecode.new(10, 30) }
+  end
+
+  def test_plus_with_int_gives_a_timecode
+    assert_equal Timecode.new(10), Timecode.new(5) + 5
+  end
+  
+  def test_min
+    a, b = Timecode.new(10), Timecode.new(4)
+    assert_equal Timecode.new(6), a - b
+  end
+
+  def test_min_with_int_gives_a_timecode
+    assert_equal Timecode.new(10), Timecode.new(15) - 5
+  end
+
+  def test_min_with_different_framerates_should_raise
+    assert_raise(Timecode::WrongFramerate) { Timecode.new(10, 25) - Timecode.new(10, 30) }
+  end
+  
+  def test_mult
+    assert_equal Timecode.new(100), Timecode.new(10) * 10
+  end
+  
+  def test_mult_by_neg_number_should_raise
+    assert_raise(Timecode::RangeError) { Timecode.new(10) * -200 }
+  end
+  
+  def test_div_by_int_gives_a_timecode
+    v = Timecode.new(200) / 20
+    assert_kind_of Timecode, v
+    assert_equal Timecode.new(10), v
+  end
+
+  def test_div_by_timecode_gives_an_int
+    v = Timecode.new(200) / Timecode.new(20)
+    assert_kind_of Numeric, v
+    assert_equal 10, v
+  end
+  
   def test_tc_with_frames_as_fraction
     tc = Timecode.new(100 -1, fps = 25)
     assert_equal 24, tc.frames
@@ -100,7 +168,43 @@ class TimecodeTest < Test::Unit::TestCase
     tc = Timecode.new(25, 12.5)
     assert_equal "00:00:02:00", tc.to_s
   end
+
+  def test_from_seconds
+    fraction = 7.1
+    tc = Timecode.from_seconds(fraction, 10)
+    assert_equal "00:00:07:01", tc.to_s
+
+    fraction = 7.5
+    tc = Timecode.from_seconds(fraction, 10)
+    assert_equal "00:00:07:05", tc.to_s
+
+    fraction = 7.16
+    tc = Timecode.from_seconds(fraction, 12.5)
+    assert_equal "00:00:07:02", tc.to_s
+  end
+
+end
+
+class TestAt < Test::Unit::TestCase
   
+  def test_at_disallows_more_than_99_hrs
+    assert_nothing_raised { Timecode.at(99,0,0,0) }
+    assert_raise(Timecode::RangeError) { Timecode.at(100,0,0,0) }
+  end
+
+  def test_at_disallows_more_than_59_mins
+    assert_raise(Timecode::RangeError) { Timecode.at(1,60,0,0) }
+  end
+
+  def test_at_disallows_more_than_59_secs
+    assert_raise(Timecode::RangeError) { Timecode.at(1,0,60,0) }
+  end
+
+  def test_at_disallows_more_frames_than_framerate
+    assert_raise(Timecode::RangeError) { Timecode.at(1,0,60,25, 25) }
+    assert_raise(Timecode::RangeError) { Timecode.at(1,0,60,32, 30) }
+  end
+
 end
 
 class TestParsing < Test::Unit::TestCase
@@ -178,18 +282,16 @@ class TestParsing < Test::Unit::TestCase
 #   assert_equal Timecode.new(17), tc
 # end
   
-  def test_from_seconds
-    fraction = 7.1
-    tc = Timecode.from_seconds(fraction, 10)
-    assert_equal "00:00:07:01", tc.to_s
-
-    fraction = 7.5
-    tc = Timecode.from_seconds(fraction, 10)
-    assert_equal "00:00:07:05", tc.to_s
-
-    fraction = 7.16
-    tc = Timecode.from_seconds(fraction, 12.5)
-    assert_equal "00:00:07:02", tc.to_s
+  def test_soft_parse_does_not_raise_and_createz_zeroed_tc
+    assert_nothing_raised do 
+      tc = Timecode.soft_parse("Meaningless nonsense", 25)
+      assert tc.zero?
+    end
+  end
+  
+  def test_parse_raoses_on_improper_format
+    assert_raise(Timecode::CannotParse) { Timecode.parse("Meaningless nonsense", 25) }
+    assert_raise(Timecode::CannotParse) { Timecode.parse("", 25) }
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timecode
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Julik
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-28 00:00:00 +01:00
+date: 2009-01-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency