timecode 1.1.0 → 1.1.2

data/History.txt

@@ -1,3 +1,12 @@
+=== 1.1.2 / 2011-10-11
+
+* Fix warnings on Ruby 1.9.3
+
+=== 1.1.1 / 2011-06-14
+
+* Fix parsing of tick frame counts in Ruby 1.9 due to Array#to_s having different semantics
+* Switch to bacon for specs.
+
 === 1.1.0 / 2011-02-16
 
 * Added timecode with ticks support, used by CineCanvas (wolfgangw)

data/Manifest.txt

@@ -3,6 +3,5 @@ History.txt
 Manifest.txt
 README.rdoc
 Rakefile
-SPECS.rdoc
 lib/timecode.rb
 test/test_timecode.rb

data/Rakefile

@@ -8,11 +8,7 @@ Hoe.spec('timecode') do |p|
   p.extra_rdoc_files  = FileList['*.rdoc']
   
   p.developer('Julik', 'me@julik.nl')
-  p.extra_dev_deps = {"test-spec" => ">=0"}
+  p.extra_dev_deps = {"bacon" => ">=0"}
   p.rubyforge_name = 'guerilla-di'
   p.remote_rdoc_dir = 'timecode'
-end
-
-task "specs" do
-  `specrb test/* --rdox > SPECS.rdoc`
 end

data/lib/timecode.rb

@@ -12,7 +12,7 @@
 #     :mapping => [%w(source_tc_frames total), %w(tape_fps fps)]
 
 class Timecode
-  VERSION = '1.1.0'
+  VERSION = '1.1.2'
 
   include Comparable
   
@@ -146,8 +146,8 @@ class Timecode
           raise RangeError, "There can be no more than 59 minutes, got #{mins}"
         when secs > 59
           raise RangeError, "There can be no more than 59 seconds, got #{secs}"
-        when frames > (with_fps -1)
-          raise RangeError, "There can be no more than #{with_fps -1} frames @#{with_fps}, got #{frames}"
+        when frames > (with_fps - 1)
+          raise RangeError, "There can be no more than #{with_fps - 1} frames @#{with_fps}, got #{frames}"
       end
     end
     
@@ -170,7 +170,7 @@ class Timecode
     # used by CineCanvas systems
     def parse_with_ticks(tc_with_ticks, fps = DEFAULT_FPS)
       ticks_expr = /(\d{3})$/
-      num_ticks = tc_with_ticks.scan(ticks_expr).to_s.to_i
+      num_ticks = tc_with_ticks.scan(ticks_expr).join.to_i
       
       raise RangeError, "Invalid tick count #{num_ticks}" if num_ticks > 249
       
@@ -337,7 +337,7 @@ class Timecode
   # 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)
-    arg.is_a?(Timecode) ?  (@total / arg.total) : self.class.new(@total /arg, @fps)
+    arg.is_a?(Timecode) ?  (@total / arg.total) : self.class.new(@total / arg, @fps)
   end
   
   # Timecodes can be compared to each other

data/test/test_timecode.rb

@@ -1,90 +1,88 @@
-require 'test/unit'
 require 'rubygems'
-require 'test/spec'
+require 'bacon'
 
-require File.dirname(__FILE__) + '/../lib/timecode'
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/timecode'
 
-
-context "Timecode.new should" do
+describe "Timecode.new should" do
   
-  specify "instantiate from int" do
+  it "should instantiate from int" do
     tc = Timecode.new(10)
     tc.should.be.kind_of Timecode
     tc.total.should.equal 10
   end
   
-  specify "always coerce FPS to float" do
+  it "should 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
+  it "should create a zero TC with no arguments" do
     Timecode.new(nil).should.be.zero?
   end
   
-  specify "accept full string SMPTE timecode as well" do
+  it "should accept full string SMPTE timecode as well" do
     Timecode.new("00:25:30:10", 25).should.equal Timecode.parse("00:25:30:10")
   end
   
 end
 
-context "Timecode.validate_atoms! should" do 
+describe "Timecode.validate_atoms! should" do 
   
-  specify "disallow more than 99 hrs" do
+  it "should disallow more than 99 hrs" do
     lambda{ Timecode.validate_atoms!(99,0,0,0, 25) }.should.not.raise
     lambda{ Timecode.validate_atoms!(100,0,0,0, 25) }.should.raise(Timecode::RangeError)
   end
   
-  specify "disallow more than 59 minutes" do
+  it "should disallow more than 59 minutes" do
     lambda{ Timecode.validate_atoms!(1,60,0,0, 25) }.should.raise(Timecode::RangeError)
   end
 
-  specify "disallow more than 59 seconds" do
+  it "should disallow more than 59 seconds" do
     lambda{ Timecode.validate_atoms!(1,0,60,0, 25) }.should.raise(Timecode::RangeError)
   end
   
-  specify "disallow more frames than what the framerate permits" do
+  it "should disallow more frames than what the framerate permits" do
     lambda{ Timecode.validate_atoms!(1,0,45,25, 25) }.should.raise(Timecode::RangeError)
     lambda{ Timecode.validate_atoms!(1,0,45,32, 30) }.should.raise(Timecode::RangeError)
   end
   
-  specify "pass validation with usable values" do
+  it "should pass validation with usable values" do
     lambda{ Timecode.validate_atoms!(20, 20, 10, 5, 25)}.should.not.raise
   end
 end
 
-context "Timecode.at should" do 
+describe "Timecode.at should" do 
   
-  specify "disallow more than 99 hrs" do
+  it "should 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
   
-  specify "disallow more than 59 minutes" do
+  it "should disallow more than 59 minutes" do
     lambda{ Timecode.at(1,60,0,0) }.should.raise(Timecode::RangeError)
   end
 
-  specify "disallow more than 59 seconds" do
+  it "should disallow more than 59 seconds" do
     lambda{ Timecode.at(1,0,60,0) }.should.raise(Timecode::RangeError)
   end
   
-  specify "disallow more frames than what the framerate permits" do
+  it "should 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
+  it "should propery accept usable values" do
     Timecode.at(20, 20, 10, 5).to_s.should.equal "20:20:10:05"
   end
 end
 
-context "A new Timecode object should" do
-  specify "be frozen" do
+describe "A new Timecode object should" do
+  it "should be frozen" do
     Timecode.new(10).should.be.frozen
   end
 end
 
-context "An existing Timecode should" do
+describe "An existing Timecode should" do
   
   before do
     @five_seconds = Timecode.new(5*25, 25)
@@ -92,47 +90,47 @@ context "An existing Timecode should" do
     @film_tc = Timecode.new(@one_and_a_half_film, 24)
   end
   
-  specify "report that the framerates are in delta" do
+  it "should report that the framerates are in delta" do
     tc = Timecode.new(1)
     tc.framerate_in_delta(25.0000000000000001, 25.0000000000000003).should.equal(true)
   end
  
-  specify "validate equality based on delta" do
+  it "should validate equality based on delta" do
     t1, t2 = Timecode.new(10, 25.0000000000000000000000000001), Timecode.new(10, 25.0000000000000000000000000002)
     t1.should.equal(t2)
   end
   
-  specify "report total as it's to_i" do
+  it "should report total as it's to_i" do
     Timecode.new(10).to_i.should.equal(10)
   end
   
-  specify "coerce itself to int" do
+  it "should coerce itself to int" do
     (10 + Timecode.new(2)).should.equal 12
   end
   
-  specify "support hours" do
+  it "should 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
+  it "should 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
+  it "should support seconds" do
     @five_seconds.should.respond_to :seconds
     @five_seconds.seconds.should.equal 5
     @film_tc.seconds.should.equal 0
   end
   
-  specify "support frames" do
+  it "should support frames" do
     @film_tc.frames.should.equal 0
   end
   
-  specify "report frame_interval as a float" do
+  it "should report frame_interval as a float" do
     tc = Timecode.new(10)
     tc.should.respond_to :frame_interval
     
@@ -141,45 +139,45 @@ context "An existing Timecode should" do
     tc.frame_interval.should.be.close 0.03333, 0.0001
   end
   
-  specify "be comparable" do
+  it "should be comparable" do
     (Timecode.new(10) < Timecode.new(9)).should.equal false
     (Timecode.new(9) < Timecode.new(10)).should.equal true
     Timecode.new(9).should.equal Timecode.new(9)
   end
   
-  specify "raise on comparison of incompatible timecodes" do
+  it "should raise on comparison of incompatible timecodes" do
     lambda { Timecode.new(10, 10) < Timecode.new(10, 20)}.should.raise(Timecode::WrongFramerate)
   end
 end
 
-context "A Timecode of zero should" do
-  specify "properly respond to zero?" do
+describe "A Timecode of zero should" do
+  it "should 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 "Timecode.from_seconds should" do
-  specify "properly process this specific case for a float framerate" do
+describe "Timecode.from_seconds should" do
+  it "should properly process this specific case for a float framerate" do
     float_secs = 89.99165971643036
     float_fps = 23.9898
     lambda{ Timecode.from_seconds(float_secs, float_fps) }.should.not.raise
   end
 end
 
-context "Timecode#to_seconds should" do
-  specify "return a float" do
+describe "Timecode#to_seconds should" do
+  it "should return a float" do
     Timecode.new(0).to_seconds.should.be.kind_of Float
   end
   
-  specify "return the value in seconds" do
+  it "should return the value in seconds" do
     fps = 24
     secs = 126.3
     Timecode.new(fps * secs, fps).to_seconds.should.be.close 126.3, 0.1
   end
   
-  specify "properly roundtrip a value via Timecode.from_seconds" do
+  it "should properly roundtrip a value via Timecode.from_seconds" do
     secs_in = 19.76
     from_secs = Timecode.from_seconds(19.76, 25.0)
     from_secs.total.should.equal 494
@@ -187,43 +185,43 @@ context "Timecode#to_seconds should" do
   end
 end
 
-context "An existing Timecode on inspection should" do
-  specify "properly present himself via inspect" do
+describe "An existing Timecode on inspection should" do
+  it "should properly present himself via inspect" do
     Timecode.new(10, 25).inspect.should.equal "#<Timecode:00:00:00:10 (10F@25.00)>"
     Timecode.new(10, 12).inspect.should.equal "#<Timecode:00:00:00:10 (10F@12.00)>"
   end
   
-  specify "properly print itself" do
+  it "should properly print itself" do
     Timecode.new(5, 25).to_s.should.equal "00:00:00:05"
   end
 end
 
-context "An existing Timecode compared by adjacency" do
-  specify "properly detect an adjacent timecode to the left" do
+describe "An existing Timecode compared by adjacency" do
+  it "should properly detect an adjacent timecode to the left" do
     Timecode.new(10).should.be.adjacent_to(Timecode.new(9))
   end
   
-  specify "properly detect an adjacent timecode to the right" do
+  it "should properly detect an adjacent timecode to the right" do
     Timecode.new(10).should.be.adjacent_to(Timecode.new(11))
   end
   
 end
 
-context "A Timecode on conversion should" do
-  specify "copy itself with a different framerate" do
+describe "A Timecode on conversion should" do
+  it "should copy itself with a different framerate" do
     tc = Timecode.new(40,25)
     at24 = tc.convert(24)
     at24.total.should.equal 40
   end
 end
 
-context "An existing Timecode used within ranges should" do
-  specify "properly provide successive value that is one frame up" do
+describe "An existing Timecode used within ranges should" do
+  it "should properly provide successive value that is one frame up" do
     Timecode.new(10).succ.total.should.equal 11
     Timecode.new(22, 45).succ.should.equal Timecode.new(23, 45) 
   end
   
-  specify "work as a range member" do
+  it "should work as a range member" do
     r = Timecode.new(10)...Timecode.new(20)
     r.to_a.length.should.equal 10
     r.to_a[4].should.equal Timecode.new(14)
@@ -231,74 +229,74 @@ context "An existing Timecode used within ranges should" do
   
 end
 
-context "A Timecode on conversion should" do
-  specify "copy itself with a different framerate" do
+describe "A Timecode on conversion should" do
+  it "should copy itself with a different framerate" do
     tc = Timecode.new(40,25)
     at24 = tc.convert(24)
     at24.total.should.equal 40
   end
 end
 
-context "A Timecode on calculations should" do
+describe "A Timecode on calculations should" do
   
-  specify "support addition" do
+  it "should support addition" do
     a, b = Timecode.new(24, 25.000000000000001), Timecode.new(22, 25.000000000000002)
     (a + b).should.equal Timecode.new(24 + 22, 25.000000000000001)
   end
   
-  specify "should raise on addition if framerates do not match" do
+  it "should should raise on addition if framerates do not match" do
     lambda{ Timecode.new(10, 25) + Timecode.new(10, 30) }.should.raise(Timecode::WrongFramerate)
   end
   
-  specify "when added with an integer instead calculate on total" do
+  it "should when added with an integer instead calculate on total" do
     (Timecode.new(5) + 5).should.equal(Timecode.new(10))
   end
   
-  specify "support subtraction" do
+  it "should support subtraction" do
     a, b = Timecode.new(10), Timecode.new(4)
     (a - b).should.equal Timecode.new(6)
   end
 
-  specify "on subtraction of an integer instead calculate on total" do
+  it "should on subtraction of an integer instead calculate on total" do
     (Timecode.new(15) - 5).should.equal Timecode.new(10)
   end
   
-  specify "raise when subtracting a Timecode with a different framerate" do
+  it "should raise when subtracting a Timecode with a different framerate" do
     lambda { Timecode.new(10, 25) - Timecode.new(10, 30) }.should.raise(Timecode::WrongFramerate)
   end
   
-  specify "support multiplication" do
+  it "should support multiplication" do
     (Timecode.new(10) * 10).should.equal(Timecode.new(100))
   end
   
-  specify "raise when the resultig Timecode is negative" do
+  it "should raise when the resultig Timecode is negative" do
     lambda { Timecode.new(10) * -200 }.should.raise(Timecode::RangeError)
   end
   
-  specify "return a Timecode when divided by an Integer" do
+  it "should return a Timecode when divided by an Integer" do
     v = Timecode.new(200) / 20
     v.should.be.kind_of(Timecode)
     v.should.equal Timecode.new(10)
   end
   
-  specify "return a number when divided by another Timecode" do
+  it "should return a number when divided by another Timecode" do
     v = Timecode.new(200) / Timecode.new(20)
     v.should.be.kind_of(Numeric)
     v.should.equal 10
   end
 end
 
-context "A Timecode used with fractional number of seconds" do
+describe "A Timecode used with fractional number of seconds" do
   
-  specify "should properly return fractional seconds" do
-    tc = Timecode.new(100 -1, fps = 25)
+  it "should should properly return fractional seconds" do
+    tc = Timecode.new(100 - 1, fps = 25)
     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
   
-  specify "properly translate to frames when instantiated from fractional seconds" do
+  it "should properly translate to frames when instantiated from fractional seconds" do
     fraction = 7.1
     tc = Timecode.from_seconds(fraction, 10)
     tc.to_s.should.equal "00:00:07:01"
@@ -314,18 +312,18 @@ context "A Timecode used with fractional number of seconds" do
 
 end
 
-context "A custom Timecode descendant should" do
+describe "A custom Timecode descendant should" do
   class CustomTC < Timecode; end
   
-  specify "properly classify on parse" do
+  it "should properly classify on parse" do
     CustomTC.parse("001").should.be.kind_of CustomTC
   end
 
-  specify "properly classify on at" do
+  it "should properly classify on at" do
     CustomTC.at(10,10,10,10).should.be.kind_of CustomTC
   end
 
-  specify "properly  classify on calculations" do
+  it "should properly  classify on calculations" do
     computed = CustomTC.parse("10h") + Timecode.new(10)
     computed.should.be.kind_of CustomTC
 
@@ -341,26 +339,26 @@ context "A custom Timecode descendant should" do
 
 end
 
-context "Timecode.parse should" do
+describe "Timecode.parse should" do
   
-  specify "handle complete SMPTE timecode" do
+  it "should handle complete SMPTE timecode" do
     simple_tc = "00:10:34:10"
     Timecode.parse(simple_tc).to_s.should.equal(simple_tc)
   end
   
-  specify "handle complete SMPTE timecode with plus for 24 frames per second" do
+  it "should handle complete SMPTE timecode with plus for 24 frames per second" do
     simple_tc = "00:10:34+10"
     p = Timecode.parse(simple_tc)
     p.to_s.should.equal(simple_tc)
     p.fps.should.equal 24
   end
   
-  specify "handle timecode with fractional seconds" do
+  it "should handle timecode with fractional seconds" do
     tc = Timecode.parse("10:10:10.2", 25)
     tc.to_s.should.equal "10:10:10:05"
   end
   
-  specify "handle timecode with ticks" do
+  it "should handle timecode with ticks" do
     tc = Timecode.parse("10:10:10:103", 25)
     tc.to_s.should.equal "10:10:10:10"
     
@@ -368,69 +366,69 @@ context "Timecode.parse should" do
     tc.to_s.should.equal "10:10:10:24"
   end
 
-  specify "raise when there are more than 249 ticks" do
+  it "should raise when there are more than 249 ticks" do
     lambda {
       tc = Timecode.parse("10:10:10:250", 25)
     }.should.raise(Timecode::RangeError)
   end
 
-  specify "handle timecode with fractional seconds with spaces at start and end" do
+  it "should handle timecode with fractional seconds with spaces at start and end" do
     tc = Timecode.parse(" 00:00:01.040 ")
     tc.to_s.should.equal "00:00:01:01"
   end
   
 # I am commenting this one out for now, these were present in some odd subtitle file.
 # What we probably need is a way for Timecode to "extract" timecodes from a chunk of text.
-# specify "handle timecode with fractional seconds with weirdo UTF spaces at start and end" do
+# it "should handle timecode with fractional seconds with weirdo UTF spaces at start and end" do
 #   tc = Timecode.parse("00:00:01.040")
 #   tc.to_s.should.equal "00:00:01:01"
 # end
   
-  specify "parse a row of numbers as parts of a timecode starting from the right" do
+  it "should 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
   
-  specify "parse a number with f suffix as frames" do
+  it "should parse a number with f suffix as frames" do
     Timecode.parse("60f").should.equal Timecode.new(60)
   end
   
-  specify "parse a number with s suffix as seconds" do
+  it "should 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
 
-  specify "parse a number with m suffix as minutes" do
+  it "should parse a number with m suffix as minutes" do
     Timecode.parse("3m").should.equal Timecode.new(25 * 60 * 3)
   end
   
-  specify "parse a number with h suffix as hours" do
+  it "should parse a number with h suffix as hours" do
     Timecode.parse("3h").should.equal Timecode.new(25 * 60 * 60 * 3)
   end
   
-  specify "parse different suffixes as a sum of elements" do
+  it "should 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'
     Timecode.parse("29f \n\n\n\n\n\    1h").to_s.should.equal '01:00:01:04'
   end
   
-  specify "parse a number of digits as timecode" do
+  it "should parse a number of digits as timecode" do
     Timecode.parse("00000001").to_s.should.equal "00:00:00:01"
     Timecode.parse("1").to_s.should.equal "00:00:00:01"
     Timecode.parse("10").to_s.should.equal "00:00:00:10"
   end
   
-  specify "truncate a large number to the parseable length" do
+  it "should truncate a large number to the parseable length" do
     Timecode.parse("1000000000000000001").to_s.should.equal "10:00:00:00"
   end
 
-  specify "left-pad a large number to give proper TC" do
+  it "should left-pad a large number to give proper TC" do
     Timecode.parse("123456", 57).to_s.should.equal "00:12:34:56"
   end
   
-  specify "parse timecode with fractional second instead of frames" do
+  it "should parse timecode with fractional second instead of frames" do
     fraction = "00:00:07.1"
     tc = Timecode.parse_with_fractional_seconds(fraction, 10)
     tc.to_s.should.equal "00:00:07:01"
@@ -448,31 +446,31 @@ context "Timecode.parse should" do
     tc.to_s.should.equal "00:00:07:02"
   end
   
-  specify "raise when trying to parse DF timecode" do
+  it "should raise when trying to parse DF timecode" do
     df_tc = "00:00:00;01"
     lambda { Timecode.parse(df_tc)}.should.raise(Timecode::Error)
   end
   
-  specify "raise on improper format" do
+  it "should raise on improper format" do
     lambda { Timecode.parse("Meaningless nonsense", 25) }.should.raise Timecode::CannotParse
     lambda { Timecode.parse("", 25) }.should.raise Timecode::CannotParse
   end
   
-  specify "raise on empty argument" do
+  it "should raise on empty argument" do
     lambda { Timecode.parse("   \n\n  ", 25) }.should.raise Timecode::CannotParse
   end
   
-  specify "properly handle 09 and 08 as part of complete TC pattern" do
+  it "should properly handle 09 and 08 as part of complete TC pattern" do
     Timecode.parse( "09:08:09:08", 25).total.should.equal 822233
   end
 end
 
-context "Timecode.soft_parse should" do
-  specify "parse the timecode" do
+describe "Timecode.soft_parse should" do
+  it "should parse the timecode" do
     Timecode.soft_parse('200').to_s.should.equal "00:00:02:00"
   end
   
-  specify "not raise on improper format and return zero TC instead" do
+  it "should not raise on improper format and return zero TC instead" do
     lambda do
       tc = Timecode.soft_parse("Meaningless nonsense", 25)
       tc.should.be.zero?
@@ -481,14 +479,14 @@ context "Timecode.soft_parse should" do
 end
 
 
-context "Timecode with unsigned integer conversions should" do
+describe "Timecode with unsigned integer conversions should" do
   
-  specify "parse from a 4x4bits packed 32bit unsigned int" do
+  it "should parse from a 4x4bits packed 32bit unsigned int" do
     uint, tc = 87310853, Timecode.at(5,34,42,5)
     Timecode.from_uint(uint).should.equal tc
   end
   
-  specify "properly convert itself back to 4x4 bits 32bit unsigned int" do
+  it "should properly convert itself back to 4x4 bits 32bit unsigned int" do
     uint, tc = 87310853, Timecode.at(5,34,42,5)
     tc.to_uint.should.equal uint
   end

metadata

@@ -1,109 +1,92 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: timecode
-version: !ruby/object:Gem::Version 
-  hash: 19
+version: !ruby/object:Gem::Version
+  version: 1.1.2
   prerelease: 
-  segments: 
-  - 1
-  - 1
-  - 0
-  version: 1.1.0
 platform: ruby
-authors: 
+authors:
 - Julik
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-15 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: test-spec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2011-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: &1348040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: hoe
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *1348040
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: &1347600 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 2
-        - 9
-        - 1
-        version: 2.9.1
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
   type: :development
-  version_requirements: *id002
-description: Value class for SMPTE timecode information
-email: 
+  prerelease: false
+  version_requirements: *1347600
+description: !binary |-
+  VmFsdWUgY2xhc3MgZm9yIFNNUFRFIHRpbWVjb2RlIGluZm9ybWF0aW9u
+email:
 - me@julik.nl
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.rdoc
-- SPECS.rdoc
-files: 
-- .DS_Store
-- History.txt
-- Manifest.txt
+extra_rdoc_files:
+- !binary |-
+  SGlzdG9yeS50eHQ=
+- !binary |-
+  TWFuaWZlc3QudHh0
 - README.rdoc
-- Rakefile
-- SPECS.rdoc
-- lib/timecode.rb
-- test/test_timecode.rb
+files:
+- !binary |-
+  LkRTX1N0b3Jl
+- !binary |-
+  SGlzdG9yeS50eHQ=
+- !binary |-
+  TWFuaWZlc3QudHh0
+- !binary |-
+  UkVBRE1FLnJkb2M=
+- !binary |-
+  UmFrZWZpbGU=
+- !binary |-
+  bGliL3RpbWVjb2RlLnJi
+- !binary |-
+  dGVzdC90ZXN0X3RpbWVjb2RlLnJi
 - .gemtest
-has_rdoc: true
 homepage: http://guerilla-di.org/timecode
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: guerilla-di
-rubygems_version: 1.4.1
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: Value class for SMPTE timecode information
-test_files: 
+summary: !binary |-
+  VmFsdWUgY2xhc3MgZm9yIFNNUFRFIHRpbWVjb2RlIGluZm9ybWF0aW9u
+test_files:
 - test/test_timecode.rb

data/SPECS.rdoc

@@ -1,116 +0,0 @@
-
-== Timecode.new should
-* instantiate from int
-* always coerce FPS to float
-* create a zero TC with no arguments
-* accept full string SMPTE timecode as well
-
-== Timecode.validate_atoms! should
-* disallow more than 99 hrs
-* disallow more than 59 minutes
-* disallow more than 59 seconds
-* disallow more frames than what the framerate permits
-* pass validation with usable values
-
-== 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
-
-== A new Timecode object should
-* be frozen
-
-== An existing Timecode should
-* report that the framerates are in delta
-* validate equality based on delta
-* report total as it's to_i
-* coerce itself to int
-* support hours
-* support minutes
-* support seconds
-* support frames
-* report frame_interval as a float
-* be comparable
-* raise on comparison of incompatible timecodes
-
-== A Timecode of zero should
-* properly respond to zero?
-
-== Timecode.from_seconds should
-* properly process this specific case for a float framerate
-
-== Timecode#to_seconds should
-* return a float
-* return the value in seconds
-* properly roundtrip a value via Timecode.from_seconds
-
-== An existing Timecode on inspection should
-* properly present himself via inspect
-* properly print itself
-
-== An existing Timecode compared by adjacency
-* properly detect an adjacent timecode to the left
-* properly detect an adjacent timecode to the right
-
-== A Timecode on conversion should
-* copy itself with a different framerate
-* copy itself with a different framerate
-
-== An existing Timecode used within ranges should
-* properly provide successive value that is one frame up
-* work as a range member
-
-== 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
-* return a Timecode when divided by an Integer
-* return 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
-
-== A custom Timecode descendant should
-* properly classify on parse
-* properly classify on at
-* properly  classify on calculations
-
-== Timecode.parse should
-* handle complete SMPTE timecode
-* handle complete SMPTE timecode with plus for 24 frames per second
-* handle timecode with fractional seconds
-* handle timecode with ticks
-* raise when there are more than 249 ticks
-* handle timecode with fractional seconds with spaces at start and end
-* 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 a number of digits as timecode
-* truncate a large number to the parseable length
-* left-pad a large number to give proper TC
-* parse timecode with fractional second instead of frames
-* raise when trying to parse DF timecode
-* raise on improper format
-* raise on empty argument
-* properly handle 09 and 08 as part of complete TC pattern
-
-== 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
-
-78 specifications (124 requirements), 0 failures