timecode 0.1.4 → 0.1.5

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.1.5 / 2009-01-14
+
+* Tests remade using test/spec
+
 === 0.1.4 / 2000-01-01
 
 * Expanded test coverage

data/Manifest.txt

@@ -1,6 +1,8 @@
 History.txt
 Manifest.txt
 README.txt
+SPECS.txt
 Rakefile
 lib/timecode.rb
-test/test_timecode.rb
+test/test_timecode.rb
+timecode.gemspec

data/Rakefile

@@ -1,15 +1,15 @@
 require 'rubygems'
-require './lib/timecode.rb'
 require 'hoe'
+require './lib/timecode.rb'
 
-Class.new(Hoe) do
-  def extra_deps
-    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
-    @extra_deps
-  end
-end.new('timecode', Timecode::VERSION) do |p|
+Hoe.new('timecode', Timecode::VERSION) do |p|
   p.developer('Julik', 'me@julik.nl')
   p.extra_deps.reject! {|e| e[0] == 'hoe' }
-  p.rubyforge_name = 'wiretap'
+  p.extra_deps << 'test-spec'
+  p.rubyforge_name = 'guerilla-di'
   p.remote_rdoc_dir = 'timecode'
+end
+
+task "specs" do
+  `specrb test/* --rdox > SPECS.txt`
 end

data/SPECS.txt

@@ -0,0 +1,74 @@
+
+== Timecode on instantiation should
+* be instantable from int
+* always coerce FPS to float
+* create a zero TC with no arguments
+
+== An existing Timecode should
+* report that the framerates are in delta
+* validate equality based on delta
+* report total as it's to_i
+* support hours
+* support minutes
+* support seconds
+* support frames
+* report frame_interval as a float
+
+== A Timecode of zero should
+* properly respond to zero?
+
+== An existing TImecode on inspection should
+* properly present himself via inspect
+* properly print itself
+
+== An existing Timecode used within ranges should
+* properly provide successive value that is one frame up
+* work as a range member
+
+== A Timecode on conversion should
+* copy itself with a different framerate
+
+== A Timecode on calculations should
+* support addition
+* should raise on addition if framerates do not match
+* when added with an integer instead calculate on total
+* support subtraction
+* on subtraction of an integer instead calculate on total
+* raise when subtracting a Timecode with a different framerate
+* support multiplication
+* raise when the resultig Timecode is negative
+* yield a Timecode when divided by an Integer
+* yield a number when divided by another Timecode
+
+== A Timecode used with fractional number of seconds
+* should properly return fractional seconds
+* properly translate to frames when instantiated from fractional seconds
+
+== Timecode.at() should
+* disallow more than 99 hrs
+* disallow more than 59 minutes
+* disallow more than 59 seconds
+* disallow more frames than what the framerate permits
+* propery accept usable values
+
+== Timecode.parse() should
+* handle complete SMPTE timecode
+* refuse to handle timecode that is out of range for the framerate
+* parse a row of numbers as parts of a timecode starting from the right
+* parse a number with f suffix as frames
+* parse a number with s suffix as seconds
+* parse a number with m suffix as minutes
+* parse a number with h suffix as hours
+* parse different suffixes as a sum of elements
+* parse timecode with fractional second instead of frames
+* raise on improper format
+
+== Timecode.soft_parse should
+* parse the timecode
+* not raise on improper format and return zero TC instead
+
+== Timecode with unsigned integer conversions should
+* parse from a 4x4bits packed 32bit unsigned int
+* properly convert itself back to 4x4 bits 32bit unsigned int
+
+48 specifications (80 requirements), 0 failures

data/lib/timecode.rb

@@ -12,15 +12,23 @@
 #     :mapping => [%w(source_tc_frames total), %w(tape_fps fps)]
 
 class Timecode
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 
   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})$/
+  
+  #:stopdoc:
+  NTSC_FPS = (30.0 * 1000 / 1001).freeze
+  ALLOWED_FPS_DELTA = (0.001).freeze
+  
+  COMPLETE_TC_RE = /^(\d{2}):(\d{2}):(\d{2}):(\d{2})$/
+  DF_TC_RE = /^(\d{1,2}):(\d{1,2}):(\d{1,2});(\d{2})$/
+  FRACTIONAL_TC_RE = /^(\d{2}):(\d{2}):(\d{2}).(\d{1,8})$/
+  
   WITH_FRACTIONS_OF_SECOND = "%02d:%02d:%02d.%02d"
   WITH_FRAMES = "%02d:%02d:%02d:%02d"
+  #:startdoc:
   
   # All Timecode lib errors inherit from this
   class Error < RuntimeError; end
@@ -31,27 +39,19 @@ class Timecode
   # Gets raised if timecode is out of range (like 100 hours long)
   class RangeError < Error; end
 
-  # Self-explanatory
-  class NonPositiveFps < RangeError; end
-
-  # Gets raised when you divide by zero
-  class TcIsZero < ZeroDivisionError; end
-
   # Gets raised when a timecode cannot be parsed
   class CannotParse < Error; end
 
   # Gets raised when you try to compute two timecodes with different framerates together
   class WrongFramerate < ArgumentError; end
-
-  # Well well...
-  class MethodRequiresTimecode < ArgumentError; end
   
   # Initialize a new Timecode object with a certain amount of frames and a framerate
   # will be interpreted as the total number of frames
   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?
-
+    
+    # If total is a string, use parse
+    raise RangeError, "Timecode cannot be negative" if total.to_i < 0
     # Always cast framerate to float, and num of rames to integer
     @total, @fps = total.to_i, fps.to_f
     @value = validate!
@@ -62,10 +62,13 @@ class Timecode
     "#<Timecode:%s (%dF@%.2f)>" % [to_s, total, fps]
   end
   
-  TIME_FIELDS = 7 # :nodoc:
-  
   class << self
     
+    # Use initialize for integers and parsing for strings
+    def new(from, fps = DEFAULT_FPS)
+      from.is_a?(String) ? parse(from, fps) : super(from, fps)
+    end
+    
     # Parse timecode and return zero if none matched
     def soft_parse(input, with_fps = DEFAULT_FPS)
       parse(input) rescue new(0, with_fps)
@@ -78,13 +81,19 @@ class Timecode
     # * 00:00:00:00 - will be parsed as zero TC
     def parse(input, with_fps = DEFAULT_FPS)
       # Drop frame goodbye
-      raise TimecodeLibError, "We do not support drop frame" if (input =~ /\;/)
+      raise Error, "We do not support drop frame" if (input =~ /\;/)
       
       hrs, mins, secs, frames = 0,0,0,0
       atoms = []
       
+      # 00:00:00:00
+      if (input =~ COMPLETE_TC_RE)
+        atoms = input.scan(COMPLETE_TC_RE).to_a.flatten
+      # 00:00:00.0
+      elsif input =~ FRACTIONAL_TC_RE
+        parse_with_fractional_seconds(input, with_fps)
       # 10h 20m 10s 1f
-      if input =~ /\s/
+      elsif input =~ /\s/
         return input.split.map{|part|  parse(part, with_fps) }.inject { |sum, p| sum + p.total }
       # 10s
       elsif input =~ /^(\d+)s$/
@@ -105,8 +114,6 @@ class Timecode
         atoms.unshift [ints.pop, ints.pop].reverse.join.to_i
         atoms.unshift [ints.pop, ints.pop].reverse.join.to_i
         atoms.unshift [ints.pop, ints.pop].reverse.join.to_i
-      elsif (input =~ COMPLETE_TC_RE)
-        atoms = input.scan(COMPLETE_TC_RE).to_a.flatten
       else
         raise CannotParse, "Cannot parse #{input} into timecode, no match"
       end
@@ -146,7 +153,7 @@ class Timecode
       seconds_per_frame = 1.0 / fps.to_f
       frame_idx = (fraction_part / seconds_per_frame).floor
 
-      tc_with_frameno = tc_with_fractions_of_second.gsub(fraction_expr, ":#{frame_idx}")
+      tc_with_frameno = tc_with_fractions_of_second.gsub(fraction_expr, ":%02d" % frame_idx)
 
       parse(tc_with_frameno, fps)
     end
@@ -321,7 +328,7 @@ class Timecode
     raise RangeError, "Timecode cannot be longer that 99 hrs" if hrs > 99 
     raise RangeError, "More than 59 minutes" if mins > 59 
     raise RangeError, "More than 59 seconds" if secs > 59
-    raise TimecodeLibError, "More than #{@fps.to_s} frames (#{frames}) in the last second" if frames >= @fps
+    raise RangeError, "More than #{@fps.to_s} frames (#{frames}) in the last second" if frames >= @fps
   
     [hrs, mins, secs, frames]
   end

data/test/test_timecode.rb

@@ -1,308 +1,318 @@
 require 'test/unit'
+require 'rubygems'
+require 'test/spec'
+
 require File.dirname(__FILE__) + '/../lib/timecode'
 
 
-class TimecodeTest < Test::Unit::TestCase
+context "Timecode on instantiation should" do
   
-  def test_timecode_with_nil_gives_zero
-    assert_equal Timecode.new(0), Timecode.new(nil)
+  specify "be instantable from int" do
+    tc = Timecode.new(10)
+    tc.should.be.kind_of Timecode
+    tc.total.should.equal 10
   end
   
-  def test_fps_always_coerced_to_float
-    t = Timecode.new(10, 25)
-    assert_kind_of Float, t.fps
+  specify "always coerce FPS to float" do
+    Timecode.new(10, 24).fps.should.be.kind_of(Float)
+    Timecode.new(10, 25.0).fps.should.be.kind_of(Float)
+  end
+  
+  specify "create a zero TC with no arguments" do
+    Timecode.new(nil).should.be.zero?
+  end
+end
 
-    t = Timecode.new(10, 25.0)
-    assert_kind_of Float, t.fps
+context "An existing Timecode should" do
+  
+  before do
+    @five_seconds = Timecode.new(5*25, 25)
+    @one_and_a_half_film = (90 * 60) * 24
+    @film_tc = Timecode.new(@one_and_a_half_film, 24)
   end
   
-  def test_framerate_in_delta
+  
+  specify "report that the framerates are in delta" do
     tc = Timecode.new(1)
-    assert tc.framerate_in_delta(25.0000000000000001, 25.0000000000000003)
+    tc.framerate_in_delta(25.0000000000000001, 25.0000000000000003).should.equal(true)
   end
-
-  def test_equality_validated_based_on_deltas
+ 
+  specify "validate equality based on delta" do
     t1, t2 = Timecode.new(10, 25.0000000000000000000000000001), Timecode.new(10, 25.0000000000000000000000000002)
-    assert t1 == t2
+    t1.should.equal(t2)
   end
   
-  def test_to_i_is_total
-    assert_equal 10, Timecode.new(10).to_i
+  specify "report total as it's to_i" do
+    Timecode.new(10).to_i.should.equal(10)
   end
   
-  def test_inspect
-    tc = Timecode.new(10, 25)
-    assert_equal "#<Timecode:00:00:00:10 (10F@25.00)>", tc.inspect
+  specify "support hours" do
+    @five_seconds.should.respond_to :hours
+    @five_seconds.hours.should.equal 0
+    @film_tc.hours.should.equal 1
+  end
+
+  specify "support minutes" do
+    @five_seconds.should.respond_to :minutes
+    @five_seconds.minutes.should.equal 0
+    @film_tc.minutes.should.equal 30
+  end
+
+  specify "support seconds" do
+    @five_seconds.should.respond_to :seconds
+    @five_seconds.seconds.should.equal 5
+    @film_tc.seconds.should.equal 0
   end
   
-  def test_equality_on_succ
-    assert_equal Timecode.parse("05:43:02:01"), Timecode.parse("05:43:02:00").succ 
+  specify "support frames" do
+    @film_tc.frames.should.equal 0
   end
   
-  def test_basics
-    five_seconds_of_pal = 5 * 25
-
-    tc = Timecode.new(five_seconds_of_pal, 25)
-    assert_equal 0, tc.hours
-    assert_equal 0, tc.minutes
-    assert_equal 5, tc.seconds
-    assert_equal 0, tc.frames
-    assert_equal five_seconds_of_pal, tc.total
-    assert_equal "00:00:05:00", tc.to_s
+  specify "report frame_interval as a float" do
+    tc = Timecode.new(10)
+    tc.should.respond_to :frame_interval
     
-    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
-    assert_equal 30, film_tc.minutes
-    assert_equal 0, film_tc.seconds
-    assert_equal 0, film_tc.frames
-    assert_equal one_and_a_half_hour_of_hollywood, film_tc.total
-    assert_equal "01:30:00:00", film_tc.to_s
-
-    assert_equal "01:30:00:04", (film_tc + 4).to_s
-    assert_equal "01:30:01:04", (film_tc + 28).to_s
+    tc.frame_interval.should.be.close 0.04, 0.0001
+    tc = Timecode.new(10, 30)
+    tc.frame_interval.should.be.close 0.03333, 0.0001
+  end
+  
+end
 
-    assert_raise(Timecode::WrongFramerate) do
-      tc + film_tc
-    end
-    
-    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
-      assert_equal "00:00:07:05", added_tc.to_s
-    end
+context "A Timecode of zero should" do
+  specify "properly respond to zero?" do
+    Timecode.new(0).should.respond_to :zero?
+    Timecode.new(0).should.be.zero
+    Timecode.new(1).should.not.be.zero
+  end
+end
 
+context "An existing TImecode on inspection should" do
+  specify "properly present himself via inspect" do
+    Timecode.new(10, 25).inspect.should.equal "#<Timecode:00:00:00:10 (10F@25.00)>"
   end
   
-  def test_succ
-    assert_equal Timecode.new(23), Timecode.new(22).succ
+  specify "properly print itself" do
+    Timecode.new(5, 25).to_s.should.equal "00:00:00:05"
   end
-  
-  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
+
+context "An existing Timecode used within ranges should" do
+  specify "properly provide successive value that is one frame up" do
+    Timecode.new(10).succ.total.should.equal 11
+    Timecode.new(22).succ.should.equal Timecode.new(23) 
   end
   
-  def test_timecode_rangeable
+  specify "work as a range member" do
     r = Timecode.new(10)...Timecode.new(20)
-    assert_equal 10, r.to_a.length
-    assert_equal Timecode.new(14), r.to_a[4]
+    r.to_a.length.should.equal 10
+    r.to_a[4].should.equal Timecode.new(14)
   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)
+context "A Timecode on conversion should" do
+  specify "copy itself with a different framerate" do
+    tc = Timecode.new(40,25)
     at24 = tc.convert(24)
-    assert_equal tc.total, at24.total
+    at24.total.should.equal 40
   end
 end
 
-class CalculationsTest < Test::Unit::TestCase
-  def test_plus
+context "A Timecode on calculations should" do
+  
+  specify "support addition" do
     a, b = Timecode.new(24, 25.000000000000001), Timecode.new(22, 25.000000000000002)
-    assert_equal Timecode.new(24 + 22, 25.000000000000001), (a + b)
+    (a + b).should.equal Timecode.new(24 + 22, 25.000000000000001)
   end
   
-  def test_plus_with_different_framerates_should_raise
-    assert_raise(Timecode::WrongFramerate) { Timecode.new(10, 25) + Timecode.new(10, 30) }
+  specify "should raise on addition if framerates do not match" do
+    lambda{ Timecode.new(10, 25) + Timecode.new(10, 30) }.should.raise(Timecode::WrongFramerate)
   end
-
-  def test_plus_with_int_gives_a_timecode
-    assert_equal Timecode.new(10), Timecode.new(5) + 5
+  
+  specify "when added with an integer instead calculate on total" do
+    (Timecode.new(5) + 5).should.equal(Timecode.new(10))
   end
   
-  def test_min
+  specify "support subtraction" do
     a, b = Timecode.new(10), Timecode.new(4)
-    assert_equal Timecode.new(6), a - b
+    (a - b).should.equal Timecode.new(6)
   end
 
-  def test_min_with_int_gives_a_timecode
-    assert_equal Timecode.new(10), Timecode.new(15) - 5
+  specify "on subtraction of an integer instead calculate on total" do
+    (Timecode.new(15) - 5).should.equal Timecode.new(10)
   end
-
-  def test_min_with_different_framerates_should_raise
-    assert_raise(Timecode::WrongFramerate) { Timecode.new(10, 25) - Timecode.new(10, 30) }
+  
+  specify "raise when subtracting a Timecode with a different framerate" do
+    lambda { Timecode.new(10, 25) - Timecode.new(10, 30) }.should.raise(Timecode::WrongFramerate)
   end
   
-  def test_mult
-    assert_equal Timecode.new(100), Timecode.new(10) * 10
+  specify "support multiplication" do
+    (Timecode.new(10) * 10).should.equal(Timecode.new(100))
   end
   
-  def test_mult_by_neg_number_should_raise
-    assert_raise(Timecode::RangeError) { Timecode.new(10) * -200 }
+  specify "raise when the resultig Timecode is negative" do
+    lambda { Timecode.new(10) * -200 }.should.raise(Timecode::RangeError)
   end
   
-  def test_div_by_int_gives_a_timecode
+  specify "yield a Timecode when divided by an Integer" do
     v = Timecode.new(200) / 20
-    assert_kind_of Timecode, v
-    assert_equal Timecode.new(10), v
+    v.should.be.kind_of(Timecode)
+    v.should.equal Timecode.new(10)
   end
-
-  def test_div_by_timecode_gives_an_int
+  
+  specify "yield a number when divided by another Timecode" do
     v = Timecode.new(200) / Timecode.new(20)
-    assert_kind_of Numeric, v
-    assert_equal 10, v
+    v.should.be.kind_of(Numeric)
+    v.should.equal 10
   end
+end
+
+context "A Timecode used with fractional number of seconds" do
   
-  def test_tc_with_frames_as_fraction
+  specify "should properly return fractional seconds" do
     tc = Timecode.new(100 -1, fps = 25)
-    assert_equal 24, tc.frames
-    assert_equal "00:00:03.96", tc.with_frames_as_fraction
-    assert_equal "00:00:03.96", tc.with_fractional_seconds
-  end
-  
-  def test_float_framerate
-    tc = Timecode.new(25, 12.5)
-    assert_equal "00:00:02:00", tc.to_s
+    tc.frames.should.equal 24
+    
+    tc.with_frames_as_fraction.should.equal "00:00:03.96"
+    tc.with_fractional_seconds.should.equal "00:00:03.96"
   end
 
-  def test_from_seconds
+  specify "properly translate to frames when instantiated from fractional seconds" do
     fraction = 7.1
     tc = Timecode.from_seconds(fraction, 10)
-    assert_equal "00:00:07:01", tc.to_s
+    tc.to_s.should.equal "00:00:07:01"
 
     fraction = 7.5
     tc = Timecode.from_seconds(fraction, 10)
-    assert_equal "00:00:07:05", tc.to_s
+    tc.to_s.should.equal "00:00:07:05"
 
     fraction = 7.16
     tc = Timecode.from_seconds(fraction, 12.5)
-    assert_equal "00:00:07:02", tc.to_s
+    tc.to_s.should.equal "00:00:07:02"
   end
 
 end
 
-class TestAt < Test::Unit::TestCase
+context "Timecode.at() should" do 
   
-  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) }
+  specify "disallow more than 99 hrs" do
+    lambda{ Timecode.at(99,0,0,0) }.should.not.raise
+    lambda{ Timecode.at(100,0,0,0) }.should.raise(Timecode::RangeError)
   end
-
-  def test_at_disallows_more_than_59_mins
-    assert_raise(Timecode::RangeError) { Timecode.at(1,60,0,0) }
+  
+  specify "disallow more than 59 minutes" do
+    lambda{ Timecode.at(1,60,0,0) }.should.raise(Timecode::RangeError)
   end
 
-  def test_at_disallows_more_than_59_secs
-    assert_raise(Timecode::RangeError) { Timecode.at(1,0,60,0) }
+  specify "disallow more than 59 seconds" do
+    lambda{ Timecode.at(1,0,60,0) }.should.raise(Timecode::RangeError)
   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) }
+  
+  specify "disallow more frames than what the framerate permits" do
+    lambda{ Timecode.at(1,0,60,25, 25) }.should.raise(Timecode::RangeError)
+    lambda{ Timecode.at(1,0,60,32, 30) }.should.raise(Timecode::RangeError)
+  end
+  
+  specify "propery accept usable values" do
+    Timecode.at(20, 20, 10, 5).to_s.should.equal "20:20:10:05"
   end
-
 end
 
-class TestParsing < Test::Unit::TestCase
 
-  def test_parse_simple
+context "Timecode.parse() should" do
+  
+  specify "handle complete SMPTE timecode" do
     simple_tc = "00:10:34:10"
-    
-    assert_nothing_raised do
-      @tc = Timecode.parse(simple_tc)
-      assert_equal simple_tc, @tc.to_s
-    end
+    Timecode.parse(simple_tc).to_s.should.equal(simple_tc)
+  end
+
+  specify "handle complete SMPTE timecode via new" do
+    simple_tc = "00:10:34:10"
+    Timecode.new(simple_tc).to_s.should.equal(simple_tc)
+  end
   
+  specify "refuse to handle timecode that is out of range for the framerate" do
     bad_tc = "00:76:89:30"
-    unknown_gobbledygook = "this is insane"
-    
-    assert_raise(Timecode::CannotParse) do
-      tc = Timecode.parse(unknown_gobbledygook, 25)
-    end
-    
-    assert_raise(Timecode::RangeError) do
-      Timecode.parse(bad_tc, 25)
-    end
+    lambda { Timecode.parse(bad_tc, 25) }.should.raise(Timecode::RangeError)
   end
   
-  def test_parse_from_numbers
-    assert_equal Timecode.new(10), Timecode.parse("10")
-    assert_equal Timecode.new(60), Timecode.parse("210")
-    assert_equal "10:10:10:10", Timecode.parse("10101010").to_s
+  specify "parse a row of numbers as parts of a timecode starting from the right" do
+    Timecode.parse("10").should.equal Timecode.new(10)
+    Timecode.parse("210").should.equal Timecode.new(60)
+    Timecode.parse("10101010").to_s.should.equal "10:10:10:10"
   end
   
-  def test_parse_with_f
-    assert_equal Timecode.new(60), Timecode.parse("60f")
+  specify "parse a number with f suffix as frames" do
+    Timecode.parse("60f").should.equal Timecode.new(60)
   end
   
-  def test_parse_s
-    assert_equal Timecode.new(50, 25), Timecode.parse("2s", 25)
-    assert_equal Timecode.new(60, 30), Timecode.parse("2s", 30)
-    assert_not_equal Timecode.new(60, 25), Timecode.parse("2s", 30)
+  specify "parse a number with s suffix as seconds" do
+    Timecode.parse("2s", 25).should.equal Timecode.new(50, 25)    
+    Timecode.parse("2s", 30).should.equal Timecode.new(60, 30)
   end
 
-  def test_parse_m
-    assert_equal Timecode.new(25 * 60 * 3), Timecode.parse("3m")
+  specify "parse a number with m suffix as minutes" do
+    Timecode.parse("3m").should.equal Timecode.new(25 * 60 * 3)
   end
-
-  def test_parse_h
-    assert_equal Timecode.new(25 * 60 * 60 * 3), Timecode.parse("3h")
+  
+  specify "parse a number with h suffix as hours" do
+    Timecode.parse("3h").should.equal Timecode.new(25 * 60 * 60 * 3)
   end
   
-  def test_parse_from_elements
-    assert_equal '01:00:00:04', Timecode.parse("1h 4f").to_s
-    assert_equal '01:00:00:04', Timecode.parse("4f 1h").to_s
-    assert_equal '01:00:01:04', Timecode.parse("29f 1h").to_s
+  specify "parse different suffixes as a sum of elements" do
+    Timecode.parse("1h 4f").to_s.should.equal '01:00:00:04'
+    Timecode.parse("4f 1h").to_s.should.equal '01:00:00:04'
+    Timecode.parse("29f 1h").to_s.should.equal '01:00:01:04'
   end
   
-  def test_parse_fractional_tc
+  specify "parse timecode with fractional second instead of frames" do
     fraction = "00:00:07.1"
     tc = Timecode.parse_with_fractional_seconds(fraction, 10)
-    assert_equal "00:00:07:01", tc.to_s
+    tc.to_s.should.equal "00:00:07:01"
 
     fraction = "00:00:07.5"
     tc = Timecode.parse_with_fractional_seconds(fraction, 10)
-    assert_equal "00:00:07:05", tc.to_s
+    tc.to_s.should.equal "00:00:07:05"
     
     fraction = "00:00:07.04"
     tc = Timecode.parse_with_fractional_seconds(fraction, 12.5)
-    assert_equal "00:00:07:00", tc.to_s
+    tc.to_s.should.equal "00:00:07:00"
     
     fraction = "00:00:07.16"
     tc = Timecode.parse_with_fractional_seconds(fraction, 12.5)
-    assert_equal "00:00:07:02", tc.to_s
+    tc.to_s.should.equal "00:00:07:02"
   end
   
-# def test_parse_with_calculation
-#   tc = Timecode.parse_with_calculation("00:00:00:15 +2f")
-#   assert_equal Timecode.new(17), tc
-# end
+  specify "raise on improper format" do
+    lambda { Timecode.parse("Meaningless nonsense", 25) }.should.raise Timecode::CannotParse
+    lambda { Timecode.parse("", 25) }.should.raise Timecode::CannotParse
+  end
   
-  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
+
+context "Timecode.soft_parse should" do
+  specify "parse the timecode" do
+    Timecode.soft_parse('200').to_s.should.equal "00:00:02:00"
   end
   
-  def test_parse_raoses_on_improper_format
-    assert_raise(Timecode::CannotParse) { Timecode.parse("Meaningless nonsense", 25) }
-    assert_raise(Timecode::CannotParse) { Timecode.parse("", 25) }
+  specify "not raise on improper format and return zero TC instead" do
+    lambda do
+      tc = Timecode.soft_parse("Meaningless nonsense", 25)
+      tc.should.be.zero?
+    end.should.not.raise
   end
 end
 
-class TestUintConversion < Test::Unit::TestCase
-  def test_from_uint
+context "Timecode with unsigned integer conversions should" do
+  
+  specify "parse from a 4x4bits packed 32bit unsigned int" do
     uint, tc = 87310853, Timecode.at(5,34,42,5)
-    assert_equal tc, Timecode.from_uint(uint)
+    Timecode.from_uint(uint).should.equal tc
   end
   
-  def test_to_uint
+  specify "properly convert itself back to 4x4 bits 32bit unsigned int" do
     uint, tc = 87310853, Timecode.at(5,34,42,5)
-    assert_equal uint, tc.to_uint
+    tc.to_uint.should.equal uint
   end
 end

data/timecode.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{timecode}
+  s.version = "0.1.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Julik"]
+  s.date = %q{2009-01-18}
+  s.description = %q{Value class for SMPTE timecode information}
+  s.email = ["me@julik.nl"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt", "SPECS.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "SPECS.txt", "Rakefile", "lib/timecode.rb", "test/test_timecode.rb", "timecode.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://wiretap.rubyforge.org/timecode}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{guerilla-di}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Value class for SMPTE timecode information}
+  s.test_files = ["test/test_timecode.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<test-spec>, [">= 0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.2"])
+    else
+      s.add_dependency(%q<test-spec>, [">= 0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.2"])
+    end
+  else
+    s.add_dependency(%q<test-spec>, [">= 0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.2"])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timecode
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Julik
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-01 00:00:00 +01:00
+date: 2009-01-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-spec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   type: :development
@@ -33,13 +43,16 @@ extra_rdoc_files:
 - History.txt
 - Manifest.txt
 - README.txt
+- SPECS.txt
 files: 
 - History.txt
 - Manifest.txt
 - README.txt
+- SPECS.txt
 - Rakefile
 - lib/timecode.rb
 - test/test_timecode.rb
+- timecode.gemspec
 has_rdoc: true
 homepage: http://wiretap.rubyforge.org/timecode
 post_install_message: 
@@ -62,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: wiretap
+rubyforge_project: guerilla-di
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2