captive 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 507732c8b1ccb140a3ad934f6c8fd4e8f05e49703ce9e48b5e07c4cb815ad6b0
+  data.tar.gz: f1c314eea9df3e4482e44db07a3ec664da05f7032712a883c7826a23096c8dbf
+SHA512:
+  metadata.gz: 1845a4d5314701d636400b753ff609638466151ba24b27edf77a6e670380cbb258388529c788e93d5e3e440c9ab84bd3d9a373d4d7d461343968ba7739834b00
+  data.tar.gz: 36f0ba341f0878eb7a2d5cb11fc36feea8182b55754762d308f7073be715ad5af208e89a22562cecad34fc66a183fd4e747e8a6879ea1b7cecf46ae3aa960739

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,94 @@
+# Captive - Ruby Subtitle Editor and Converter
+
+Captive can read subtitles from various formats. Subtitles can be modified and exported to another format as well as JSON. Captive currently supports `SRT` and `WebVTT` formats.
+
+## Supported Features
+
+- Read subtitles
+- Convert to another format (SRT, WebVTT)
+- Save to file
+- Serialize as JSON
+
+
+## Usage
+
+**Parse subtitles**
+
+Subtitles can be read from a file using `from_file` and providing a filename
+
+```ruby
+s = Captive::SRT.from_file(filename: 'test.srt')
+
+s = Captive::VTT.from_file(filename: 'test.vtt')
+```
+
+Alternately, subtitles can be parsed from a blob of text if you don't want to load from a file
+```ruby
+s = Captive::SRT.from_blob(filename: 'test.srt')
+
+s = Captive::VTT.from_blob(filename: 'test.vtt')
+```
+
+Or to get instantiate an empty captive object simply
+```ruby
+s = Captive::SRT.new
+
+s = Captive::VTT.new
+```
+
+**Save to File**
+
+Subtitles can be saved to a file using `save_as`
+```ruby
+s = Captive::VTT.from_file(filename: 'test.vtt')
+s.save_as(filaname: 'output.vtt')
+```
+
+**Serializing as JSON**
+
+Need to store your subtitle data in a format agnostic way? `as_json` is your friend
+```ruby
+s = Captive::VTT.from_file(filename: 'test.vtt')
+s.as_json
+```
+
+**Switch Formats**
+
+Subtitles parsed in one format can be converted to another format. Currently, **SRT** and **WebVTT** are supported.
+
+```ruby
+s = Captive::SRT.new('test.srt')
+vtt = s.as_vtt # Will return a Captive::VTT instance
+vtt.save_as(filename: 'conversion.vtt')
+```
+
+
+## Installation
+
+Simply add `captive` to your Gemfile
+
+```ruby
+gem 'captive'
+```
+
+Or install it yourself with:
+
+    $ gem install captive
+
+## Dependencies
+
+Captive is lightweight and has no external dependencies.
+
+## Development
+
+After cloning the repo, run `bundle install` to get the development dependencies. Use `bin/console` to spin up an IRB instance with captive loaded.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mserran2/captive.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'captive'
+require 'irb'
+IRB.start

data/lib/captive.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'captive/version'
+require 'captive/error'
+require 'captive/util'
+require 'captive/base'
+require 'captive/cue'
+require 'captive/formats/vtt'
+require 'captive/formats/srt'

data/lib/captive/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Captive
+  module Base
+    module ClassMethods
+      def from_file(filename:)
+        file = File.new(filename, 'r:bom|utf-8')
+        blob = file.read
+        from_blob(blob: blob)
+      ensure
+        file&.close
+      end
+
+      def from_blob(blob:)
+        new(cue_list: parse(blob: blob))
+      end
+
+      def from_json(json:, mapping: {})
+        json = JSON.parse(json) if json.is_a?(String)
+        cues = json['cues'] || json[:cues]
+        raise InvalidJsonInput unless cues.is_a?(Array)
+
+        cues.map! { |cue_json| Cue.from_json(json: cue_json, mapping: mapping) }
+        new(cue_list: cues)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(Util)
+    end
+
+    attr_accessor(:cues)
+
+    def initialize(cue_list: nil)
+      @cues = cue_list || []
+    end
+
+    def save_as(filename:)
+      File.open(filename, 'w') do |file|
+        file.write(to_s)
+      end
+    end
+
+    def as_json(**args)
+      results = {
+        'version' => VERSION,
+        'cues' => cues.map(&:as_json),
+      }
+      if results.respond_to?(:as_json)
+        results.as_json(**args)
+      else
+        results
+      end
+    end
+
+    def method_missing(method_name, *_args)
+      super unless (match = /^as_([a-z]+)$/.match(method_name))
+
+      if valid_format?(match.captures.first.upcase)
+        define_format_conversion(method_name, match.captures.first.upcase)
+        send(method_name)
+      elsif valid_format?(match.captures.first.capitalize)
+        define_format_conversion(method_name, match.captures.first.capitalize)
+        send(method_name)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _)
+      super unless (match = /^as_([a-z]+)$/.match(method_name))
+
+      return true if valid_format?(match.captures.first.upcase) || valid_format?(match.captures.first.capitalize)
+
+      super
+    end
+
+    private
+
+    def base_klass
+      base = self.class.to_s.split('::')
+      Kernel.const_get(base.first)
+    end
+
+    def valid_format?(format)
+      base_klass.const_defined?(format) && base_klass.const_get(format).include?(Base)
+    end
+
+    def define_format_conversion(method_name, format)
+      self.class.define_method(method_name) do
+        if self.class.to_s.split('::').last == format
+          self
+        else
+          base_klass.const_get(format).new(cue_list: cues)
+        end
+      end
+    end
+  end
+end

data/lib/captive/cue.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Captive
+  class Cue
+    include Util
+
+    # Text Properties supported
+    ALIGNMENT    = 'alignment'
+    COLOR        = 'color'
+    POSITION     = 'position'
+
+    # List of Text Properties
+    TEXT_PROPERTIES = [ALIGNMENT, COLOR, POSITION].freeze
+
+    attr_accessor :text, :properties
+    attr_reader :start_time, :end_time
+
+    # Creates a new Cue class denoting a subtitle.
+    def initialize(text: nil, start_time: nil, end_time: nil, properties: {})
+      self.text = text
+      self.start_time = start_time
+      self.end_time = end_time
+      self.properties = properties || {}
+    end
+
+    def self.from_json(json:, mapping: {})
+      schema = {}
+      %i[text! start_time! end_time! properties].each do |field|
+        field_name = field.to_s.delete('!')
+        schema[field] = mapping[field_name] || mapping[field_name.to_sym] || field_name.to_sym
+      end
+      data = {}
+      schema.each do |mask, mapper|
+        key = mask[-1] == '!' ? mask.to_s[0...-1].to_sym : mask
+        if key.to_s != mask.to_s && !(json.key?(mapper.to_s) || json.key?(mapper.to_sym))
+          raise InvalidJsonInput, "Cue missing field: #{mapper}"
+        end
+
+        data[key] = json[mapper.to_s] || json[mapper.to_sym]
+      end
+      new(**data)
+    end
+
+    def start_time=(time)
+      set_time(:start_time, time)
+    end
+
+    def end_time=(time)
+      set_time(:end_time, time)
+    end
+
+    def set_times(start_time:, end_time:)
+      self.start_time = start_time
+      self.end_time = end_time
+    end
+
+    # Getter and Setter methods for Text Properties
+    TEXT_PROPERTIES.each do |setting|
+      define_method :"#{setting}" do
+        return properties[setting] if properties[setting].present?
+
+        return nil
+      end
+
+      define_method :"#{setting}=" do |value|
+        properties[setting] = value
+      end
+    end
+
+    def duration
+      end_time - start_time
+    end
+
+    # Adds text. If text is already present, new-line is added before text.
+    def add_text(text)
+      if self.text.nil?
+        self.text = text
+      else
+        self.text += "\n" + text
+      end
+    end
+
+    def <=>(other)
+      start_time <=> other.start_time
+    end
+
+    def as_json(**args)
+      options = args.delete(:options) || {}
+      format = options['format'] || {}
+      obj = {
+        'start_time' => format[:time] == :timecode ? milliseconds_to_timecode(start_time) : start_time,
+        'end_time' => format[:time] == :timecode ? milliseconds_to_timecode(end_time) : end_time,
+        'text' => text,
+        'properties' => properties,
+      }
+      obj.respond_to?(:as_json) ? obj.as_json(**args) : obj
+    end
+
+    private
+
+    def set_time(field, time)
+      return if time.nil?
+
+      if time.is_a?(Integer)
+        instance_variable_set("@#{field}", time)
+      elsif TIMECODE_REGEX.match(time)
+        instance_variable_set("@#{field}", timecode_to_milliseconds(time))
+      else
+        raise InvalidInput, "Input for #{field} should be an integer denoting milliseconds or a valid timecode."
+      end
+    end
+  end
+end

data/lib/captive/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Captive
+  # Base error class.
+  class CaptiveError < StandardError
+  end
+
+  # Error denoting a malformed string during subtitle parsing.
+  class MalformedString < CaptiveError
+  end
+
+  # Error denoting a malformed subtitle input format.
+  class InvalidSubtitle < CaptiveError
+  end
+
+  # Error denoting incorrect input to a method.
+  class InvalidInput < CaptiveError
+  end
+
+  class InvalidJsonInput < CaptiveError
+  end
+end

data/lib/captive/formats/srt.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Captive
+  class SRT
+    include Base
+
+    def self.parse(blob:)
+      cue_list = []
+      lines = blob.split("\n")
+      count = 0
+      state = :new_cue
+      cue = nil
+
+      lines.each_with_index do |line, _index|
+        line.strip!
+        case state
+        when :new_cue
+          next if line.empty? ## just another blank line, remain in new_cue state
+
+          raise InvalidSubtitle, "Invalid Cue Number at line #{count}" if /^\d+$/.match(line).nil?
+
+          state = :time
+        when :time
+          raise InvalidSubtitle, "Invalid Time Format at line #{count}" unless timecode?(line)
+
+          start_time, end_time = line.split('-->').map(&:strip)
+          cue = Cue.new(
+            start_time: format_time(start_time),
+            end_time: format_time(end_time)
+          )
+          state = :text
+        when :text
+          if line.empty?
+            ## end of previous cue
+            cue_list << cue
+            cue = nil
+            state = :new_cue
+          else
+            cue.add_text(line)
+          end
+        end
+      end
+
+      # Check to make sure we add the last cue if for some reason the file lacks an empty line at the end
+      cue_list << cue unless cue.nil?
+
+      # Return the cue_list
+      cue_list
+    end
+
+    def to_s
+      string = String.new
+      cues.each_with_index do |cue, index|
+        string << (index + 1).to_s
+        string << "\n"
+        string << milliseconds_to_timecode(cue.start_time).gsub!('.', ',')
+        string << ' --> '
+        string << milliseconds_to_timecode(cue.end_time).gsub!('.', ',')
+        string << "\n"
+        string << cue.text
+        string << "\n\n"
+      end
+      string
+    end
+
+    def self.format_time(text)
+      text.strip.gsub(/,/, '.')
+    end
+
+    def self.timecode?(text)
+      !!text.match(/^\d{2,}:\d{2}:\d{2},\d{3}.*\d{2,}:\d{2}:\d{2},\d{3}$/)
+    end
+  end
+end

data/lib/captive/formats/vtt.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Captive
+  class VTT
+    include Base
+
+    # Standard VTT Header
+    VTT_HEADER = 'WEBVTT'
+
+    # VTT METADATA Regex
+    VTT_METADATA = /^NOTE|^STYLE/.freeze
+
+    # Parse VTT blob and return array of cues
+    def self.parse(blob:)
+      cue_list = []
+      lines = blob.split("\n")
+      state = :new_cue
+      cue = nil
+      raise InvalidSubtitle, 'Invalid VTT Signature' unless validate_header(lines.shift)
+
+      lines.each_with_index do |line, index|
+        line.strip!
+
+        case state
+        when :new_cue
+          next if line.empty?
+
+          if metadata?(line)
+            state = :metadata
+            next
+          end
+
+          # If its not metadata, and its not an empty line, it should be a timestamp or an identifier
+          unless time?(line)
+            # If this line is an identifier the next line should be a timecode
+            next if time?(lines[index + 1])
+
+            raise InvalidSubtitle, "Invalid Time Format at line #{index + 1}" unless time?(line)
+          end
+
+          elements = line.split
+          start_time = elements[0]
+          end_time = elements[2]
+          cue = Cue.new(start_time: start_time, end_time: end_time)
+          state = :text
+        when :text
+          if line.empty?
+            ## end of previous cue
+            cue_list << cue
+            cue = nil
+            state = :new_cue
+          else
+            cue.add_text(line)
+          end
+        when :metadata
+          next unless line.empty?
+
+          # Line is empty which means metadata block is over
+          state = :new_cue
+        end
+      end
+
+      # Check to make sure we add the last cue if for some reason the file lacks an empty line at the end
+      cue_list << cue unless cue.nil?
+
+      # Return the cue_list
+      cue_list
+    end
+
+    # Dump contents to String
+    def to_s
+      string = VTT_HEADER.dup
+      string << "\n\n"
+      cues.each do |cue|
+        string << milliseconds_to_timecode(cue.start_time)
+        string << ' --> '
+        string << milliseconds_to_timecode(cue.end_time)
+        string << "\n"
+        string << cue.text
+        string << "\n\n"
+      end
+      string
+    end
+
+    # VTT Header tag matcher
+    def self.validate_header(line)
+      # Make sure BOM does not interfere with header detection
+      !!line.force_encoding('UTF-8').delete("\xEF\xBB\xBF").strip.match(/^#{VTT_HEADER}/)
+    end
+
+    # VTT Metadata tag matcher
+    def self.metadata?(text)
+      !!text.match(VTT_METADATA)
+    end
+
+    # VTT Timecode matcher
+    def self.time?(text)
+      !!text.match(/^(\d{2}:)?\d{2}:\d{2}.\d{3}.*(\d{2}:)?\d{2}:\d{2}.\d{3}/)
+    end
+
+    def self.integer?(val)
+      val.to_i.to_s == val
+    end
+  end
+end

data/lib/captive/util.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Captive
+  module Util
+    TIMECODE_REGEX = /^(\d{2,}:)?[0-5]\d:[0-5]\d(\.\d{1,3})?$/.freeze
+
+    # Converts timecode in HH:MM:SS.MSEC (or) MM:SS.MSEC to milliseconds.
+    def timecode_to_milliseconds(timecode)
+      raise InvalidInput, 'Input should be a valid Timecode' unless TIMECODE_REGEX.match(timecode)
+
+      timecode_split = timecode.split('.')
+      time_split = timecode_split[0].split(':')
+
+      # To handle MM:SS.MSEC format
+      time_split.unshift('00') if time_split.length == 2
+
+      # Get HH:MM:SS in seconds
+      seconds = time_split[-1].to_i
+      seconds += minutes_to_seconds(time_split[-2].to_i)
+      seconds += hours_to_seconds(time_split[-3].to_i)
+
+      milliseconds = seconds_to_milliseconds(seconds)
+
+      # Millisecond component exists. Pad it to make sure its a full 3 digits
+      milliseconds += timecode_split[1].ljust(3, '0').to_i if timecode_split[1]
+
+      milliseconds
+    end
+
+    def minutes_to_seconds(minutes)
+      minutes * 60
+    end
+
+    def hours_to_seconds(hours)
+      minutes_to_seconds(hours * 60)
+    end
+
+    def seconds_to_milliseconds(seconds)
+      seconds * 1000
+    end
+
+    # Converts milliseconds to timecode format and returns HH+:MM:SS.MSEC where hours are two or more characters.
+    def milliseconds_to_timecode(milliseconds)
+      ms_in_a_second = 1000
+      ms_in_a_minute = ms_in_a_second * 60
+      ms_in_an_hour = ms_in_a_minute * 60
+
+      hours, remaider = milliseconds.divmod(ms_in_an_hour)
+      minutes, remaider = remaider.divmod(ms_in_a_minute)
+      seconds, milliseconds = remaider.divmod(ms_in_a_second)
+
+      format('%<h>02d:%<m>02d:%<s>02d.%<ms>03d', { h: hours, m: minutes, s: seconds, ms: milliseconds })
+    end
+  end
+end

data/lib/captive/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Captive
+  VERSION = '1.1.1'
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: captive
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- mserran2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.87'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.87.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.87'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.87.1
+description: Captive allows for parsing and converting of subtitles across different
+  formats in addition to JSON
+email:
+- mark@markserrano.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- lib/captive.rb
+- lib/captive/base.rb
+- lib/captive/cue.rb
+- lib/captive/error.rb
+- lib/captive/formats/srt.rb
+- lib/captive/formats/vtt.rb
+- lib/captive/util.rb
+- lib/captive/version.rb
+homepage: https://github.com/mserran2/captive
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby Subtitle Manager, Editor and Converter
+test_files: []