secret
anonymous / RobisonWRSantos
Last active

  • Download Gist
RobisonWRSantos
Ruby
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
#!/usr/bin/ruby -w
#File: shift_subtitle.rb
=begin
Robison WR Santos (rwrsantos@gmail.com)
26/09/2009
 
Difficulty: Ruby beginner.
 
Goals: Basic control over Ruby elements, specially command line scripting.
 
Description: There are several ways to subtitle a movie nowadays, and one of
the most well known format is the SubRip format
http://en.wikipedia.org/wiki/SubRip). It has entries like these:
 
--------------------------------------------------------------------------------
645
01:31:51,210 --> 01:31:54,893
the government is implementing a new policy...
 
646
01:31:54,928 --> 01:31:57,664
In connection with a dramatic increase
in crime in certain neighbourhoods,
--------------------------------------------------------------------------------
 
Each line has an increasing integer identification, then comes the time range
(start and end time) in the format “hours:minutes:seconds,milliseconds”.
The decimal separator used is the comma. Finally there are the subtitles
themselves and a line break marks the end of an entry.
 
Sometimes the timing is shifted for a small amount, 2 or 3 seconds. Then comes
the trouble when you need to shift everything a few seconds back or ahead.
 
The goal is to create a small command line script in Ruby that will read an SRT
file, and output another one with the new calculated times.
 
So, for example, if I want to shift everything 2,500 (2 seconds and 500
milliseconds) ahead, I would start with this:
 
--------------------------------------------------------------------------------
01:32:04,283 --> 01:32:07,769
--------------------------------------------------------------------------------
 
and end up with:
 
--------------------------------------------------------------------------------
01:32:06,783 --> 01:32:10,269
--------------------------------------------------------------------------------
 
The command line should accept arguments such as:
 
shift_subtitle --operation add --time 02,110 input_file output_file
 
This means “--operation” can accept either ‘add’ or ’sub’ to add or subtract
times. The “--time” will accept the amount of time to shift in the format 11,222
where “11? is the amount of seconds and “222? the amount of milliseconds.
 
Requirements: This has to be a pure Ruby script, using only the Ruby Standard
Libraries (meaning, no external Gems).
 
It has to implement “optparse” to parse the command line arguments.
=end
 
require 'time_shifter'
require 'optparse'
 
if __FILE__ == $0
options = {}
OptionParser.new do |opt|
opt.banner = "Usage: shift_subtitle.rb [options] input_file output_file"
opt.on("--operation=add|sub","Operation to be performed, 'add' or 'sub'.") do |op|
options[:operation] = op
end
opt.on("--time=time","Time to be added or subtract in seconds",
"[and milliseconds, separeted by comma or period].") do |t|
options[:time] = t
end
opt.on_tail("-h", "--help", "Show this message.") do
puts opt
exit
end
end.parse!
if ARGV.size \d{2}:\d{2}:\d{2},\d{3}$/
 
t = Time.now.to_f
begin
File.open(ARGV[1],'w') do |fout| #output_file
File.open(ARGV[0],'r') do |fin| #input_file
while line = fin.gets
line = line.chomp if line
if line =~ TIME_PATTERN
line = line.split(' --> ')
in_time = TimeShifter.shift(line[0],options[:time],options[:operation])
out_time = TimeShifter.shift(line[1],options[:time],options[:operation])
fout.puts "#{in_time} --> #{out_time}"
else
fout.puts line
end
end
end #closes input_file
end #closes output_file
rescue TimeShifter::InvalidOperation
puts "\n[ERROR]: A valid operation should be either 'add' or 'sub'."
exit!
rescue TimeShifter::IlegalTimeFormat
puts "\n[ERROR]: An IlegalTimeFormat error has occured. Please verify your" +
"time parameter or your file format."
exit!
rescue SystemCallError
puts "\n[ERROR]: An error has occured. Maybe your input file does not exist."
exit!
end
 
puts "\n[SUCCESS]: It took #{Time.now.to_f - t} seconds to finish..."
end
time_shifter.rb
Ruby
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
#file: time_shifter.rb
=begin
Robison WR Santos (rwrsantos@gmail.com)
26/09/2009
=end
 
class TimeShifter
# Declaring error classes
InvalidOperation = Class.new(StandardError)
IlegalTimeFormat = Class.new(StandardError)
 
# This method must receive a time to be shifted.
# The time_in parameter is a string in format hh:mm:ss,millisecond.
# The amount_to_shift parameter is a string representing the amount of time
# to be shifted.
# The operation parameter is a string representing whether it should add or
# subtract the amount to shift tp/from the time in.
def self.shift(time_in, amount_to_shift='0', operation='add')
#Validates entry
raise IlegalTimeFormat,"time_in should respect the format #{/^\d{2}:\d{2}:\d{2},\d{3}$/}" unless time_in =~ /\d{2}:\d{2}:\d{2},\d{3}$/
raise IlegalTimeFormat, "amount_to_shift should respect the format #{/^\d+([,\.]\d+)?$/}" unless amount_to_shift =~ /^\d+([,\.]\d+)?$/
#Transforms into values
time = real_time(time_in)
amount = amount_to_shift.gsub(',','.').to_f
time = case operation
when 'add'
time + amount
when 'sub'
time - amount
else
raise InvalidOperation
end
# Return the formated string
string_time(time.to_f)
end
# Transorms the string time in a real time value in seconds.
def self.real_time(time)
# get all values of time_in in parts
time = time.gsub(',','.').split(':').reverse
#transform all time in a time value (seconds,microsseconds)
(time.size-1).downto(1) do |i|
time[i-1] = time[i-1].to_f + time[i].to_f * 60
end
time[0]
end
# Transorms a real time representation into a string representation.
def self.string_time(time)
# get the seconds and minutes
all_minutes = (time / 60).to_i
all_seconds = time % 60
# get the hours and minutes
hours = all_minutes / 60
minutes = all_minutes % 60
# filter seconds
seconds = all_seconds.to_i
# filter milliseconds
milliseconds = ((all_seconds - seconds) * 1000).round
"#{hours.to_s.rjust(2,'0')}:#{minutes.to_s.rjust(2,'0')}:#{seconds.to_s.rjust(2,'0')},#{milliseconds.to_s.rjust(3,'0')}"
end
end
time_shifter_rspec.tb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
#File: time_shifter_rspec.tb
=begin
RSpec test file for TimeShifter class.
Robison WR Santos (rwrsantos@gmail.com)
26/09/2009
=end
require 'time_shifter'
 
describe TimeShifter do
it 'shoud have a way t shift an string' do
TimeShifter.should respond_to(:shift)
end
 
it 'should return the same string if only time_in is passed as parameter of
shift method and its finished with one zero' do
time_in = "01:02:03,450"
TimeShifter.shift(time_in).should == time_in
end
it 'should return the same string if only time_in is passed as parameter of
shift method and its finished with two zero' do
time_in = "01:02:03,400"
TimeShifter.shift(time_in).should == time_in
end
it 'should return the same string if only time_in is passed as parameter of
shift method and its finished with three zeros' do
time_in = "01:02:03,000"
TimeShifter.shift(time_in).should == time_in
end
it 'should return the same string if only time_in is passed as parameter of
shift method' do
time_in = "01:02:03,456"
TimeShifter.shift(time_in).should == time_in
end
it 'should have a way to tranform the string time into a float value' do
TimeShifter.should respond_to(:real_time)
end
it 'should return a value of seconds and milliseconds of an string
representation of time' do
string_time = "01:02:03,456"
TimeShifter.real_time(string_time).should == 3723.456
end
it 'should have a way to tranform a real time array into its the string time
representation' do
TimeShifter.should respond_to(:real_time)
end
it 'should return a string representation of a real time array value containing
[seconds,milliseconds]' do
real_time = 3723.456000
TimeShifter.string_time(real_time).should == "01:02:03,456"
end
it 'should add a time in seconds and milliseconds when an operation is not
provided for shifting' do
time_in = "01:02:03,456"
amount_to_shift = "65,432"
TimeShifter.shift(time_in,amount_to_shift).should == "01:03:08,888"
end
it 'should add a time in seconds and milliseconds when an operation "add" is
provided for shifting' do
time_in = "01:02:03,456"
amount_to_shift = "65,432"
TimeShifter.shift(time_in,amount_to_shift,"add").should == "01:03:08,888"
end
it 'should subtract a time in seconds and milliseconds when an operation "sub"
is provided for shifting' do
time_in = "01:02:03,456"
amount_to_shift = "65,432"
TimeShifter.shift(time_in,amount_to_shift,"sub").should == "01:00:58,024"
end
it 'should raise "InvalidOperation" when an operation different from "add" or
"sub" is provided' do
lambda {TimeShifter.shift("01:02:03,456","65,432","any")}.should raise_error(TimeShifter::InvalidOperation)
end
it 'should raise "IlegalTimeFormat" when an ilegal time format is provided
as time_in' do
lambda {TimeShifter.shift("00:00","65,432")}.should raise_error(TimeShifter::IlegalTimeFormat)
end
it 'should raise "IlegalTimeFormat" when an ilegal time format is provided as
amount_to_shift' do
lambda {TimeShifter.shift("00:00:00,000","65..00")}.should raise_error(TimeShifter::IlegalTimeFormat)
end
it 'should not raise "IlegalTimeFormat" when amount_to_shift is provided with
period instead of comma' do
lambda {TimeShifter.shift("00:00:00,000","65.0")}.should_not raise_error(TimeShifter::IlegalTimeFormat)
end
it 'should not raise "IlegalTimeFormat" when amount_to_shift is provided as
an integer (string without comma or period' do
lambda {TimeShifter.shift("00:00:00,000","65")}.should_not raise_error(TimeShifter::IlegalTimeFormat)
end
end

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.