captions 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df484fcb870ba6563846a9a5f9ba3dd6af72bef1
+  data.tar.gz: 4a1ddcd8ac296fc4da482f99c2e34f2f377d1973
+SHA512:
+  metadata.gz: f9dba92584da98bb74c7f353b9f33b124d827d89db0df2b707be75f8a4a70b425358bc1fef8c09af112f4e4884c5397916b3d458d8d734ac05401747bc286073
+  data.tar.gz: bd37c14625543e6a40743eff374464affd9a154d19a0e680907a43b6c0c658a9789fa043408e3f486772053c56ee829dcda947a04c247ebaa3feac1af8ec668a

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.0.0-p247
+
+script: 'bundle exec rspec'
+
+notifications:
+  email:
+    recipients:
+      - navinre93@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in captions.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 navin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,127 @@
+# Captions - Subtitle Editor and Converter
+
+[![Build Status](https://travis-ci.org/navinre/captions.svg?branch=master)](https://travis-ci.org/navinre/captions)
+
+Captions can read subtitles of various formats, modify them and convert the subtitle to other formats. Currently captions supports `SRT`, `WebVTT` files.
+
+## Supported Features
+- Read subtitles
+- Move subtitles
+- Increase duration
+- Filter subtitles
+- Change frame rate
+- Convert to other format (SRT, WebVTT)
+
+## Features Planned
+- Read subtitle properties (Font Style, Aligment, Position etc.)
+- Delete subtitles
+- Change subtitle fonts
+- Command Line Interface
+- Spell Check
+- And More...
+
+
+## Usage
+
+**Read subtitle file:**
+
+```ruby
+s = Captions::SRT.new('test.srt')
+s.parse
+
+s = Captions::VTT.new('test.vtt')
+s.parse
+```
+
+**Filter subtitles:**
+
+Once the subtitle file has been parsed. Every subtitle will get **start_time, end_time, duration and text**. All the values are stored in milliseconds. `Captions::InvalidSubtitle` error will be thown if start-time or end-time cannot be found for a subtitle.
+
+View all subtitle text:
+```ruby
+s.cues.map { |c| c.text }
+```
+
+Filter subtitles based on condition:
+```ruby
+s.cues { |c| c.start_time > 1000 }
+s.cues { |c| c.end_time > 1000 }
+s.cues { |c| c.duration > 1000 }
+```
+
+To get all subtitles:
+```ruby
+s.cues.each { |c| puts c }
+```
+
+**Move Subtitle:**
+
+```ruby
+s.move_by(1000)
+s.move_by(1000) { |c| c.start_time > 3000 }
+```
+
+Former command moves all subtitles by 1 second. Later moves the subtitles which are starting after 3 seconds by 1 second.
+
+**Increase Duration:**
+
+```ruby
+s.increase_duration_by(1000)
+s.increase_duration_by(1000) { |c| c.start_time > 3000 }
+```
+
+Former command increases duration of all subtitles by 1 second. Later increases the duration of subtitles which are starting after 3 seconds by 1 second.
+
+**Change Frame Rate:**
+
+All subtitles are parsed based on **25 frames/second** by default. This can be changed by passing frame rate at the time of reading the subtitle file.
+
+```ruby
+s = Captions::SRT.new('test.srt', 29.97)
+s.parse
+```
+
+Frame rate can also be changed after parsing. This command changes all the subtitles which are parsed in different frame-rate to new frame-rate.
+
+```ruby
+s.set_frame_rate(29.97)
+```
+
+**Convert to Other Format:**
+
+Subtitles parsed in one format can be converted to other format. Currently export is supported for **SRT** and **WebVTT**. Other formats will be added soon.
+
+```ruby
+s = Captions::SRT.new('test.srt')
+s.parse
+s.export_to_vtt('test.vtt')
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'captions'
+```
+
+Or install it yourself as:
+
+    $ gem install captions
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/navinre/captions.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "captions"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/captions.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'captions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "captions"
+  spec.version       = Captions::VERSION
+  spec.authors       = ["navin"]
+  spec.email         = ["navin@amagi.com"]
+
+  spec.summary       = %q{Subtitle Editor and Converter written in Ruby}
+  spec.description   = %q{Subtitle Editor and Converter written in Ruby. Captions can read/modify/export subtitles from one format to another }
+  spec.homepage      = "https://github.com/navinre/captions"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/captions/base.rb

@@ -0,0 +1,162 @@
+module Captions
+  class Base
+
+    # Adding Util methods so that it can be used by
+    # any subtitle parser
+    include Util
+
+    # Creates new instance of parser
+    # Usage:
+    #     p = Captions::Base.new(nil, 25)
+    #
+    # This creates new cue-list with no file object
+    # associated with it. `parse` method cannot be
+    # called if no file path is specified.
+    #
+    #    p = Captions::Base.new('file_path', 25)
+    #
+    # This parses the file specified in the file path
+    # `parse` method will be defined in any one of the
+    # classes which extends this base class. This parses
+    # the file in the fps specified. If a subtitle file
+    # has to be parsed in different fps, it can be passed
+    # as a parameter. FPS parameter plays an important
+    # role if the start-time or end-time of a subtitle is
+    # mentioned in frames (i.e) HH:MM:SS:FF (frames)
+    def initialize(file=nil, fps=25)
+      @cue_list = CueList.new(fps)
+      @file = File.new(file, 'r:bom|utf-8') if file
+    end
+
+    # This overrides the existing cuelist which has been
+    # populated with a new cuelist. This is mainly used in
+    # export of one format to another.
+    def cues=(cue_list)
+      @cue_list = cue_list
+    end
+
+    ############## BEGINNING OF OPERATIONS #################
+    ## Following Operations can performed on subtitles
+
+    # A subtitle is parsed with 25 fps by default. This default
+    # value can be changed when creating a new parser class.
+    # When the subtitle is being parsed, it takes the value
+    # mentioned when the class is created. Even after the
+    # subtitle is parsed, frame rate (fps) can be changed using
+    # this method.
+    # Usage:
+    #     p = Captions::Base.new('file_path', 25)
+    #     p.parse
+    #     p.set_frame_rate(29.97)
+    #
+    # This method changes all the subtitle which are parsed to
+    # the new frame rate.
+    def set_frame_rate(rate)
+      @cue_list.frame_rate = rate
+    end
+
+    # This returns the subtitle which are parsed. A block
+    # can also be passed to filter the cues based on following
+    # parameters.
+    # Usage:
+    #     p.cues
+    #     p.cues { |c| c.start_time > 1000 }
+    #     p.cues { |c| c.end_time > 1000 }
+    #     p.cues { |c| c.duration > 1000 }
+    #
+    # Filters based on the condition and returns new set of cues
+    def cues(&block)
+      if block_given?
+        base = self.class.new()
+        base.cues = fetch_result(&block)
+        return base.cues
+      else
+        @cue_list
+      end
+    end
+
+    # Moves subtitles by `n` milliseconds
+    # Usage:
+    #     p.move_by(1000)
+    #     p.move_by("00:00:02.000")
+    #     p.move_by(1000) { |c| c.start_time > 2000 }
+    #
+    # This changes start-time and end-time of subtiltes by
+    # the time passed.
+    def move_by(diff, &block)
+      msec = sanitize(diff, frame_rate)
+      fetch_result(&block).each do |cue|
+        cue.start_time += msec
+        cue.end_time += msec
+      end
+    end
+
+    # Increases duration of subtitles by `n` milliseconds
+    # Usage:
+    #     p.increase_duration_by(1000)
+    #     p.increase_duration_by("00:00:02.000")
+    #     p.increase_duration_by(1000) { |c| c.start_time > 2000 }
+    #
+    # This increases duration of subtiltes by the time passed.
+    def increase_duration_by(diff, &block)
+      msec = sanitize(diff, frame_rate)
+      fetch_result(&block).each do |cue|
+        cue.duration += msec
+      end
+    end
+
+    ################ END OF OPERATIONS ###################
+
+    private
+
+    # This is the base method through which all subtitle
+    # file parsing should be done. This throws error if
+    # no `@file` is found. This also closes the file once
+    # the file has be parsed. All other logic like when the
+    # subtitle has to be inserted into the list, when to set
+    # the start and end time will be defined inside `parse`
+    # method.
+    def base_parser
+      raise UnknownFile, "No subtitle file specified" if @file.nil?
+      begin
+        yield
+      ensure
+        @file.close
+      end
+      return true
+    end
+
+    # This is the base method through which all subtitle
+    # exports has to be done. When a `file_path` is passed
+    # to this base method, it opens the file. Other logic
+    # about how the file should be written is defined inside
+    # `dump` method in one of the subclass.
+    def base_dump(file)
+      begin
+        File.open(file, 'w') do |file|
+          yield(file)
+        end
+      end
+      return true
+    end
+
+    # This returns the frame-rate which was used for parsing
+    # the subtitles
+    def frame_rate
+      @cue_list.fps
+    end
+
+    # This accepts a block and returns the result based
+    # on the condition passed. This acts on the cuelist
+    # whenever a block is passed it does select with the
+    # condition passed and returns the result. When no
+    # block is passed, it returns the entire cuelist.
+    def fetch_result(&block)
+      if block_given?
+        @cue_list.select(&block)
+      else
+        @cue_list
+      end
+    end
+  end
+end

data/lib/captions/cue.rb

@@ -0,0 +1,66 @@
+module Captions
+  class Cue
+    include Util
+
+    attr_accessor :number, :start_time, :end_time, :duration, :text, :property
+
+    # Creates a new Cue class
+    # Each cue denotes a subtitle.
+    def initialize
+      self.text = nil
+      self.start_time = nil
+      self.end_time = nil
+      self.duration = nil
+      self.number = nil
+      self.property = {}
+    end
+
+    # Sets the time for the cue. Both start-time and
+    # end-time can be passed together. This just assigns
+    # the value passed.
+    def set_time(start_time, end_time, duration = nil)
+      self.start_time = start_time
+      self.end_time = end_time
+      self.duration = duration
+    end
+
+    # Serializes the values set for the cue.
+    # Converts start-time, end-time and duration to milliseconds
+    # If duration is not found, it will be calculated based on
+    # start-time and end-time.
+    def serialize(fps)
+      raise InvalidSubtitle, "Subtitle should have start time" if self.start_time.nil?
+      raise InvalidSubtitle, "Subtitle shold have end time" if self.end_time.nil?
+
+      begin
+        ms_per_frame = (1000.0 / fps)
+        self.start_time = convert_to_msec(self.start_time, ms_per_frame)
+        self.end_time = convert_to_msec(self.end_time, ms_per_frame)
+        if duration.nil?
+          self.duration = self.end_time - self.start_time
+        else
+          self.duration = convert_to_msec(self.duration, ms_per_frame)
+        end
+      rescue
+        raise InvalidSubtitle, "Cannot calculate start-time or end-time"
+      end
+    end
+
+    # Changes start-time, end-time and duration based on new frame-rate
+    def change_frame_rate(old_rate, new_rate)
+      self.start_time = convert_frame_rate(self.start_time, old_rate, new_rate)
+      self.end_time = convert_frame_rate(self.end_time, old_rate, new_rate)
+      self.duration = convert_frame_rate(self.duration, old_rate, new_rate)
+    end
+
+    # Adds text. If text is already found, new-line is appended.
+    def add_text(text)
+      if self.text.nil?
+        self.text = text
+      else
+        self.text += "\n" + text
+      end
+    end
+
+  end
+end

data/lib/captions/error.rb

@@ -0,0 +1,27 @@
+module Captions
+
+  # Used for all execptions thrown from captions
+  class CaptionsError < StandardError
+  end
+
+  # Subtitle has to be in correct format
+  # when its being serialized
+  class InvalidSubtitle < CaptionsError
+  end
+
+  # Subtitle has to be correct format
+  # when its being parsed
+  class MalformedString < CaptionsError
+  end
+
+  # File has to be specifed for parsing
+  # subtitle
+  class UnknownFile < CaptionsError
+  end
+
+  # Input has to be proper for filtering
+  # subtitles
+  class InvalidInput < CaptionsError
+  end
+
+end

data/lib/captions/export.rb

@@ -0,0 +1,25 @@
+module Captions
+
+  # This module adds support for export of subtitles
+  # from one format to another. Subclasses which
+  # extends Captions::Base needs to `dump` method to
+  # support export to that corresponding format
+  module Export
+    Captions.constants.each do |format|
+      obj = Captions.const_get(format)
+      next unless obj.is_a?(Class) and (obj.superclass == Captions::Base)
+      method_name = "export_to_" + format.to_s.downcase
+      define_method(method_name) do |file|
+        sub_format = obj.new()
+        sub_format.cues = self.cues.dup
+        sub_format.dump(file) if sub_format.respond_to?(:dump)
+      end
+    end
+  end
+
+  # Including this module after all the sub-classes of
+  # Captions::Base has been defined.
+  Captions::Base.send(:include, Export)
+
+end
+

data/lib/captions/formats/srt.rb

@@ -0,0 +1,65 @@
+module Captions
+  class SRT < Base
+
+    def parse
+      base_parser do
+        count = 1
+        cue = nil
+        while(line = @file.gets) do
+          line = line.strip
+          if is_number?(line)
+            @cue_list.append(cue) if cue
+            cue = Cue.new
+            cue.number = line.to_i
+          elsif is_time?(line)
+            s , e = get_time(line)
+            cue.set_time(s, e)
+          elsif is_text?(line)
+            cue.add_text(line)
+          elsif !line.empty?
+            raise MalformedString, "Invalid format at line #{count}"
+          end
+          count += 1
+        end
+        @cue_list.append(cue)
+      end
+    end
+
+    def dump(file)
+      base_dump(file) do |file|
+        @cue_list.each do |cue|
+          file.write(cue.number)
+          file.write("\n")
+          file.write(msec_to_timecode(cue.start_time).gsub!('.' , ','))
+          file.write(" --> ")
+          file.write(msec_to_timecode(cue.end_time).gsub!('.' , ','))
+          file.write("\n")
+          file.write(cue.text)
+          file.write("\n\n")
+        end
+      end
+    end
+
+    def get_time(line)
+      data = line.split('-->')
+      return format_time(data[0]), format_time(data[1])
+    end
+
+    def format_time(text)
+      text.strip.gsub(/,/,".")
+    end
+
+    def is_number?(text)
+      !!text.match(/^\d+$/)
+    end
+
+    def is_time?(text)
+      !!text.match(/^\d{2}:\d{2}:\d{2},\d{3}.*\d{2}:\d{2}:\d{2},\d{3}$/)
+    end
+
+    def is_text?(text)
+      !text.empty? and text.is_a?(String)
+    end
+
+  end
+end

data/lib/captions/formats/vtt.rb

@@ -0,0 +1,63 @@
+module Captions
+	class VTT < Base
+
+    # Header used for all VTT files
+		VTT_HEADER = "WEBVTT"
+
+    # Parse VTT file and update CueList
+		def parse
+			base_parser do
+				count = 1
+				cue_count = 0
+				cue = nil
+				while(line = @file.gets) do
+					line = line.strip
+					if line.empty?
+						@cue_list.append(cue) if cue
+						cue_count += 1
+						cue = Cue.new
+						cue.number = cue_count
+					elsif is_time?(line)
+						s, e = get_time(line)
+						cue.set_time(s, e)
+					elsif is_text?(line)
+						cue.add_text(line)
+					end
+				end
+				@cue_list.append(cue)
+			end
+		end
+
+    # Export CueList to VTT file
+		def dump(file)
+			base_dump(file) do |file|
+				file.write(VTT_HEADER)
+				@cue_list.each do |cue|
+					file.write("\n\n")
+					file.write(msec_to_timecode(cue.start_time))
+					file.write(" --> ")
+					file.write(msec_to_timecode(cue.end_time))
+					file.write("\n")
+					file.write(cue.text)
+				end
+			end
+		end
+
+    # Timecode format used in VTT file
+    def is_time?(text)
+      !!text.match(/^\d{2}:\d{2}:\d{2}.\d{3}.*\d{2}:\d{2}:\d{2}.\d{3}/)
+    end
+
+    # Get start-time and end-time
+    def get_time(line)
+      data = line.split('-->')
+      return data[0], data[1]
+    end
+
+    # Check whether if its subtilte text or not
+    def is_text?(text)
+      !text.empty? and text.is_a?(String) and text != VTT_HEADER
+    end
+
+	end
+end

data/lib/captions/list.rb

@@ -0,0 +1,42 @@
+module Captions
+  class CueList
+    include Enumerable
+
+    # Creates a new CueList
+    def initialize(frame_rate)
+      @fps = frame_rate
+      @list = []
+    end
+
+    # Returns frame-rate of the list
+    def fps
+      @fps
+    end
+
+    # Hide all cues when inspecting CueList
+    # Show only necessary info rather than printing everything
+    def inspect
+      "#<Captions::CueList:#{object_id} @fps=#{fps} @cues=#{@list.count}>"
+    end
+
+    # Changes the frame rate of CueList
+    # This also changes frame rate in already parsed
+    # subtitles
+    def frame_rate=(rate)
+      @list.each { |c| c.change_frame_rate(@fps, rate) }
+      @fps = rate
+    end
+
+    # Inserts the subtitle into the CueList
+    # Subtitle is serialized before its inserted
+    def append(cue)
+      cue.serialize(@fps)
+      @list << cue
+    end
+
+    # Iterate through CueList
+    def each
+      @list.each { |c| yield(c) }
+    end
+  end
+end

data/lib/captions/util.rb

@@ -0,0 +1,82 @@
+module Captions
+  module Util
+
+    # TC should be HH:MM:SS:FF (frames) or HH:MM:SS.MSC (milliseconds).
+    # FF(2 digits) and MSC(3 digits) are optional.
+    TIMECODE_REGEX = /^-?([01]\d|2[0-3]):[0-5]\d:[0-5]\d(:\d{2}|\.\d{3})?$/
+
+    # Currently considering frame rate as 25
+    # Converts time-code in HH:MM:SS.MSEC (or) HH:MM:SS:FF
+    # to milliseconds.
+    def convert_to_msec(tc, ms_per_frame=40)
+      msec = 0
+      negative_multiplier = 1
+      if tc[0] == '-'
+        tc = tc[1..-1]  # remove -ve sign
+        negative_multiplier = -1
+      end
+      tc_split = tc.split('.')
+      time_split = tc_split[0].split(':')
+
+      if tc_split[1]  # msec component exists
+        msec = tc_split[1].ljust(3, '0').to_i  # pad with trailing 0s to make it 3 digit
+      elsif time_split.length == 4  # FF (frame) component exists
+        msec = time_split[-1].to_i * ms_per_frame.to_f
+        time_split.pop  # so that below code can work from last index
+      end
+
+      min = 60
+      hour = min * 60
+      # Get HH:MM:SS in seconds
+      sec = time_split[-1].to_i
+      sec += time_split[-2].to_i * min
+      sec += time_split[-3].to_i * hour
+
+      msec += sec * 1000
+
+      return (negative_multiplier * msec.round) # to be consistent with tc_to_frames which also rounds
+    end
+
+    # Converts milliseconds calculated in one frame-rate to another frame-rate
+    def convert_frame_rate(msec, old_fps, new_fps)
+      old_ms_per_frame = (1000.0 / old_fps)
+      new_ms_per_frame = (1000.0 / new_fps)
+      frames = (msec / old_ms_per_frame).round  # Number of frames in old fps
+      sec = frames / old_fps
+      frames = frames % old_fps
+      new_frames = sec * new_fps
+      new_frames += frames # Number of frames in new fps
+      return (new_frames * new_ms_per_frame).round  # MSEC in new fps
+    end
+
+    # Converts milliseconds to timecode format
+    # Currently returns HH:MM:SS.MSEC
+    # Supports upto 60 hours
+    def msec_to_timecode(milliseconds)
+      seconds = milliseconds / 1000
+      msec = milliseconds % 1000
+      secs = seconds % 60
+
+      seconds = seconds / 60
+      mins = seconds % 60
+
+      seconds = seconds / 60
+      hours = seconds % 60
+
+      format("%02d:%02d:%02d.%03d",hours, mins, secs ,msec)
+    end
+
+    # Parses time-code and converts it to milliseconds.
+    # If time cannot be converted to milliseconds,
+    # it throws InvalidInput Error
+    def sanitize(time, frame_rate)
+      if time.is_a?(String)
+        if TIMECODE_REGEX.match(time)
+          time = convert_to_msec(time, frame_rate)
+        end
+      end
+      raise InvalidInput, 'Input should be in Milliseconds or Timecode' unless time.is_a? (Fixnum)
+      return time
+    end
+  end
+end

data/lib/captions/version.rb

@@ -0,0 +1,3 @@
+module Captions
+  VERSION = "1.0.1"
+end

data/lib/captions.rb

@@ -0,0 +1,10 @@
+require 'captions/version'
+require 'captions/error'
+require 'captions/util'
+require 'captions/base'
+require 'captions/list'
+require 'captions/cue'
+require 'captions/formats/srt'
+require 'captions/formats/vtt'
+
+require 'captions/export'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: captions
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- navin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 'Subtitle Editor and Converter written in Ruby. Captions can read/modify/export
+  subtitles from one format to another '
+email:
+- navin@amagi.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- captions.gemspec
+- lib/captions.rb
+- lib/captions/base.rb
+- lib/captions/cue.rb
+- lib/captions/error.rb
+- lib/captions/export.rb
+- lib/captions/formats/srt.rb
+- lib/captions/formats/vtt.rb
+- lib/captions/list.rb
+- lib/captions/util.rb
+- lib/captions/version.rb
+homepage: https://github.com/navinre/captions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Subtitle Editor and Converter written in Ruby
+test_files: []