youtube-transcript-rb 0.1.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a1c99bcacf517440c8be67c4e72f29406c2a7cee87cb844317a5693d5f1aea
-  data.tar.gz: d19bc462f35d6d50dd13c452b3be468c5efb57bf5cdb894c22ad99be409485da
+  metadata.gz: 60cad31d1d80bf186d231cf3eed48cd1599f41000a3de1a185e24480421ea0dd
+  data.tar.gz: cc370e6e42208f18a0ed456800de0f2e8b470754c63908149171c5558e15500a
 SHA512:
-  metadata.gz: b87fab280855a4f3f3b22786789085349492d42dd8fff3b14284b762c656757c8bd07fcfbc084ed551bd489c60ab175e4e57216edcd93c27345cfbeac53507f8
-  data.tar.gz: bba30d381a9a685e8c6f1bfeae9fdb40a81a758142a3c0c1659cc1de182266bcb6d85cff575ffade9559c945c9ae23e4c829e10821955605974ee12d499e61e3
+  metadata.gz: 42f16cf9961a05528f4289886ebb08b2b06cb9060fbecfc6b41ffd4267920ef0d2123afec048c231a4f507bd44a8f1df9e383addbb3390e4e9076d9617bb22ba
+  data.tar.gz: b529273917d15dca2f50d28b5c7ea6f04d359c111346bd0ef4547db86b7a016dae83fdefce80b75784b43849931c6595c67833d4977e8b816176bca027883491

data/.rubocop.yml

@@ -0,0 +1,9 @@
+inherit_from: .rubocop_todo.yml
+
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.2

data/.rubocop_todo.yml

@@ -0,0 +1,166 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2026-01-09 13:39:24 UTC using RuboCop version 1.82.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 3
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowUnusedKeywordArguments, IgnoreEmptyMethods, IgnoreNotImplementedMethods, NotImplementedExceptions.
+# NotImplementedExceptions: NotImplementedError
+Lint/UnusedMethodArgument:
+  Exclude:
+    - 'lib/youtube_rb/formatters.rb'
+
+# Offense count: 3
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 25
+
+# Offense count: 1
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 103
+
+# Offense count: 2
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/CyclomaticComplexity:
+  Max: 14
+
+# Offense count: 7
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 29
+
+# Offense count: 1
+# Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
+Metrics/ParameterLists:
+  Max: 7
+
+# Offense count: 2
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 15
+
+# Offense count: 1
+# Configuration parameters: ExpectMatchingDefinition, CheckDefinitionPathHierarchy, CheckDefinitionPathHierarchyRoots, Regex, IgnoreExecutableScripts, AllowedAcronyms.
+# CheckDefinitionPathHierarchyRoots: lib, spec, test, src
+# AllowedAcronyms: CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS
+Naming/FileName:
+  Exclude:
+    - 'Rakefile.rb'
+    - 'lib/youtube-transcript-rb.rb'
+
+# Offense count: 3
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
+Naming/MethodParameterName:
+  Exclude:
+    - 'lib/youtube_rb/formatters.rb'
+
+# Offense count: 2
+RSpec/BeforeAfterAll:
+  Exclude:
+    - '**/spec/spec_helper.rb'
+    - '**/spec/rails_helper.rb'
+    - '**/spec/support/**/*.rb'
+    - 'spec/integration_spec.rb'
+
+# Offense count: 2
+# Configuration parameters: IgnoredMetadata.
+RSpec/DescribeClass:
+  Exclude:
+    - '**/spec/features/**/*'
+    - '**/spec/requests/**/*'
+    - '**/spec/routing/**/*'
+    - '**/spec/system/**/*'
+    - '**/spec/views/**/*'
+    - 'spec/integration_spec.rb'
+    - 'spec/settings_spec.rb'
+
+# Offense count: 30
+# Configuration parameters: CountAsOne.
+RSpec/ExampleLength:
+  Max: 22
+
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+RSpec/ExpectActual:
+  Exclude:
+    - '**/spec/routing/**/*'
+    - 'spec/integration_spec.rb'
+
+# Offense count: 2
+# Configuration parameters: Max, AllowedIdentifiers, AllowedPatterns.
+RSpec/IndexedLet:
+  Exclude:
+    - 'spec/transcript_spec.rb'
+
+# Offense count: 91
+RSpec/MultipleExpectations:
+  Max: 7
+
+# Offense count: 44
+# Configuration parameters: AllowSubject.
+RSpec/MultipleMemoizedHelpers:
+  Max: 11
+
+# Offense count: 3
+# Configuration parameters: AllowedGroups.
+RSpec/NestedGroups:
+  Max: 4
+
+# Offense count: 7
+# Configuration parameters: CustomTransform, IgnoreMethods, IgnoreMetadata, InflectorPath, EnforcedInflector.
+# SupportedInflectors: default, active_support
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - '**/spec/routing/**/*'
+    - 'spec/api_spec.rb'
+    - 'spec/errors_spec.rb'
+    - 'spec/formatters_spec.rb'
+    - 'spec/transcript_list_fetcher_spec.rb'
+    - 'spec/transcript_list_spec.rb'
+    - 'spec/transcript_parser_spec.rb'
+    - 'spec/transcript_spec.rb'
+
+# Offense count: 10
+# Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
+RSpec/VerifiedDoubles:
+  Exclude:
+    - 'spec/api_spec.rb'
+    - 'spec/errors_spec.rb'
+    - 'spec/transcript_list_fetcher_spec.rb'
+    - 'spec/transcript_spec.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/youtube_rb/transcript.rb'
+
+# Offense count: 8
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, MaxUnannotatedPlaceholdersAllowed, Mode, AllowedMethods, AllowedPatterns.
+# SupportedStyles: annotated, template, unannotated
+Style/FormatStringToken:
+  Exclude:
+    - 'lib/youtube_rb/formatters.rb'
+
+# Offense count: 1168
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, ConsistentQuotesInMultiline.
+# SupportedStyles: single_quotes, double_quotes
+Style/StringLiterals:
+  Enabled: false
+
+# Offense count: 6
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 142

data/README.md

@@ -47,9 +47,9 @@ gem install youtube-transcript-rb
 The easiest way to get a transcript for a given video is to execute:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 api.fetch(video_id)
 ```
 
@@ -62,14 +62,14 @@ api.fetch(video_id)
 This will return a `FetchedTranscript` object looking somewhat like this:
 
 ```ruby
-#<Youtube::Transcript::Rb::FetchedTranscript
+#<YoutubeRb::Transcript::FetchedTranscript
   @video_id="12345",
   @language="English",
   @language_code="en",
   @is_generated=false,
   @snippets=[
-    #<Youtube::Transcript::Rb::TranscriptSnippet @text="Hey there", @start=0.0, @duration=1.54>,
-    #<Youtube::Transcript::Rb::TranscriptSnippet @text="how are you", @start=1.54, @duration=4.16>,
+    #<YoutubeRb::Transcript::TranscriptSnippet @text="Hey there", @start=0.0, @duration=1.54>,
+    #<YoutubeRb::Transcript::TranscriptSnippet @text="how are you", @start=1.54, @duration=4.16>,
     # ...
   ]
 >
@@ -78,7 +78,7 @@ This will return a `FetchedTranscript` object looking somewhat like this:
 This object implements `Enumerable`, so you can iterate over it:
 
 ```ruby
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 fetched_transcript = api.fetch(video_id)
 
 # is iterable
@@ -117,13 +117,13 @@ an array of hashes:
 You can also use the convenience methods on the module directly:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
 # Fetch a transcript
-transcript = Youtube::Transcript::Rb.fetch(video_id)
+transcript = YoutubeRb::Transcript.fetch(video_id)
 
 # List available transcripts
-transcript_list = Youtube::Transcript::Rb.list(video_id)
+transcript_list = YoutubeRb::Transcript.list(video_id)
 ```
 
 ### Retrieve different languages
@@ -132,7 +132,7 @@ You can add the `languages` param if you want to make sure the transcripts are r
 (it defaults to english).
 
 ```ruby
-Youtube::Transcript::Rb::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de', 'en'])
+YoutubeRb::Transcript::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de', 'en'])
 ```
 
 It's an array of language codes in a descending priority. In this example it will first try to fetch the german
@@ -142,7 +142,7 @@ which languages are available first, [have a look at `list`](#list-available-tra
 If you only want one language, you still need to format the `languages` argument as an array:
 
 ```ruby
-Youtube::Transcript::Rb::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de'])
+YoutubeRb::Transcript::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de'])
 ```
 
 ### Preserve formatting
@@ -151,7 +151,7 @@ You can also add `preserve_formatting: true` if you'd like to keep HTML formatti
 and `<b>` (bold).
 
 ```ruby
-Youtube::Transcript::Rb::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de', 'en'], preserve_formatting: true)
+YoutubeRb::Transcript::YouTubeTranscriptApi.new.fetch(video_id, languages: ['de', 'en'], preserve_formatting: true)
 ```
 
 ### List available transcripts
@@ -159,7 +159,7 @@ Youtube::Transcript::Rb::YouTubeTranscriptApi.new.fetch(video_id, languages: ['d
 If you want to list all transcripts which are available for a given video you can call:
 
 ```ruby
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 transcript_list = api.list(video_id)
 ```
 
@@ -220,9 +220,9 @@ puts translated_transcript.fetch
 ### By example
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 
 # retrieve the available transcripts
 transcript_list = api.list('video_id')
@@ -262,7 +262,7 @@ transcript = transcript_list.find_generated_transcript(['de', 'en'])
 You can fetch transcripts for multiple videos at once:
 
 ```ruby
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 
 # Fetch multiple videos
 transcripts = api.fetch_all(['video1', 'video2', 'video3'])
@@ -297,14 +297,14 @@ The `Formatters` module provides a few basic formatters:
 Here is how to import from the `Formatters` module:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
 # Some provided formatter classes, each outputs a different string format.
-Youtube::Transcript::Rb::Formatters::JSONFormatter
-Youtube::Transcript::Rb::Formatters::TextFormatter
-Youtube::Transcript::Rb::Formatters::PrettyPrintFormatter
-Youtube::Transcript::Rb::Formatters::WebVTTFormatter
-Youtube::Transcript::Rb::Formatters::SRTFormatter
+YoutubeRb::Formatters::JSONFormatter
+YoutubeRb::Formatters::TextFormatter
+YoutubeRb::Formatters::PrettyPrintFormatter
+YoutubeRb::Formatters::WebVTTFormatter
+YoutubeRb::Formatters::SRTFormatter
 ```
 
 ### Formatter Example
@@ -312,12 +312,12 @@ Youtube::Transcript::Rb::Formatters::SRTFormatter
 Let's say we wanted to retrieve a transcript and store it to a JSON file. That would look something like this:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new
 transcript = api.fetch(video_id)
 
-formatter = Youtube::Transcript::Rb::Formatters::JSONFormatter.new
+formatter = YoutubeRb::Formatters::JSONFormatter.new
 
 # .format_transcript(transcript) turns the transcript into a JSON string.
 json_formatted = formatter.format_transcript(transcript)
@@ -334,7 +334,7 @@ Since `JSONFormatter` leverages `JSON.generate` you can also forward keyword arg
 `.format_transcript(transcript)` such as making your file output prettier:
 
 ```ruby
-json_formatted = Youtube::Transcript::Rb::Formatters::JSONFormatter.new.format_transcript(
+json_formatted = YoutubeRb::Formatters::JSONFormatter.new.format_transcript(
   transcript, 
   indent: '  ',
   space: ' '
@@ -346,9 +346,9 @@ json_formatted = Youtube::Transcript::Rb::Formatters::JSONFormatter.new.format_t
 You can also use the `FormatterLoader` to dynamically load formatters by name:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
-loader = Youtube::Transcript::Rb::Formatters::FormatterLoader.new
+loader = YoutubeRb::Formatters::FormatterLoader.new
 
 # Load by type name: "json", "pretty", "text", "webvtt", "srt"
 formatter = loader.load("json")
@@ -364,7 +364,7 @@ You can implement your own formatter class. Just inherit from the `Formatter` ba
 `format_transcript` and `format_transcripts` methods which should ultimately return a string:
 
 ```ruby
-class MyCustomFormatter < Youtube::Transcript::Rb::Formatters::Formatter
+class MyCustomFormatter < YoutubeRb::Formatters::Formatter
   def format_transcript(transcript, **options)
     # Do your custom work in here, but return a string.
     'your processed output data as a string.'
@@ -382,28 +382,28 @@ end
 The library provides a comprehensive set of exceptions for different error scenarios:
 
 ```ruby
-require 'youtube/transcript/rb'
+require 'youtube_rb/transcript'
 
 begin
-  transcript = Youtube::Transcript::Rb.fetch(video_id)
-rescue Youtube::Transcript::Rb::TranscriptsDisabled => e
+  transcript = YoutubeRb::Transcript.fetch(video_id)
+rescue YoutubeRb::Transcript::TranscriptsDisabled => e
   puts "Subtitles are disabled for this video"
-rescue Youtube::Transcript::Rb::NoTranscriptFound => e
+rescue YoutubeRb::Transcript::NoTranscriptFound => e
   puts "No transcript found for the requested languages"
   puts e.requested_language_codes
-rescue Youtube::Transcript::Rb::NoTranscriptAvailable => e
+rescue YoutubeRb::Transcript::NoTranscriptAvailable => e
   puts "No transcripts are available for this video"
-rescue Youtube::Transcript::Rb::VideoUnavailable => e
+rescue YoutubeRb::Transcript::VideoUnavailable => e
   puts "The video is no longer available"
-rescue Youtube::Transcript::Rb::TooManyRequests => e
+rescue YoutubeRb::Transcript::TooManyRequests => e
   puts "Rate limited by YouTube"
-rescue Youtube::Transcript::Rb::RequestBlocked => e
+rescue YoutubeRb::Transcript::RequestBlocked => e
   puts "Request blocked by YouTube"
-rescue Youtube::Transcript::Rb::IpBlocked => e
+rescue YoutubeRb::Transcript::IpBlocked => e
   puts "Your IP has been blocked by YouTube"
-rescue Youtube::Transcript::Rb::PoTokenRequired => e
+rescue YoutubeRb::Transcript::PoTokenRequired => e
   puts "PO token required - this is a YouTube limitation"
-rescue Youtube::Transcript::Rb::CouldNotRetrieveTranscript => e
+rescue YoutubeRb::Transcript::CouldNotRetrieveTranscript => e
   puts "Could not retrieve transcript: #{e.message}"
 end
 ```
@@ -456,11 +456,11 @@ http_client = Faraday.new do |conn|
   conn.adapter Faraday.default_adapter
 end
 
-api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new(http_client: http_client)
+api = YoutubeRb::Transcript::YouTubeTranscriptApi.new(http_client: http_client)
 api.fetch(video_id)
 
 # Share same connection between two instances
-api_2 = Youtube::Transcript::Rb::YouTubeTranscriptApi.new(http_client: http_client)
+api_2 = YoutubeRb::Transcript::YouTubeTranscriptApi.new(http_client: http_client)
 api_2.fetch(video_id)
 ```
 

data/lib/youtube-transcript-rb.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "youtube_rb/transcript"
+require_relative "youtube_rb/formatters"

data/lib/youtube_rb/formatters.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "json"
+
+module YoutubeRb
+  # Module containing all transcript formatters
+  module Formatters
+    # Base formatter class. All formatters should inherit from this class
+    # and implement their own format_transcript and format_transcripts methods.
+    class Formatter
+      # Format a single transcript
+      #
+      # @param transcript [FetchedTranscript] The transcript to format
+      # @param options [Hash] Additional formatting options
+      # @return [String] The formatted transcript
+      def format_transcript(transcript, **options)
+        raise NotImplementedError, "Subclass must implement #format_transcript"
+      end
+
+      # Format multiple transcripts
+      #
+      # @param transcripts [Array<FetchedTranscript>] The transcripts to format
+      # @param options [Hash] Additional formatting options
+      # @return [String] The formatted transcripts
+      def format_transcripts(transcripts, **options)
+        raise NotImplementedError, "Subclass must implement #format_transcripts"
+      end
+    end
+
+    # Formats transcript as pretty-printed Ruby data structures
+    class PrettyPrintFormatter < Formatter
+      # Format a single transcript as pretty-printed output
+      #
+      # @param transcript [FetchedTranscript] The transcript to format
+      # @param options [Hash] Options passed to PP.pp
+      # @return [String] Pretty-printed transcript data
+      def format_transcript(transcript, **options)
+        require "pp"
+        PP.pp(transcript.to_raw_data, +"", options[:width] || 79)
+      end
+
+      # Format multiple transcripts as pretty-printed output
+      #
+      # @param transcripts [Array<FetchedTranscript>] The transcripts to format
+      # @param options [Hash] Options passed to PP.pp
+      # @return [String] Pretty-printed transcripts data
+      def format_transcripts(transcripts, **options)
+        require "pp"
+        data = transcripts.map(&:to_raw_data)
+        PP.pp(data, +"", options[:width] || 79)
+      end
+    end
+
+    # Formats transcript as JSON
+    class JSONFormatter < Formatter
+      # Format a single transcript as JSON
+      #
+      # @param transcript [FetchedTranscript] The transcript to format
+      # @param options [Hash] Options passed to JSON.generate (e.g., :indent, :space)
+      # @return [String] JSON representation of the transcript
+      def format_transcript(transcript, **options)
+        JSON.generate(transcript.to_raw_data, options)
+      end
+
+      # Format multiple transcripts as JSON array
+      #
+      # @param transcripts [Array<FetchedTranscript>] The transcripts to format
+      # @param options [Hash] Options passed to JSON.generate
+      # @return [String] JSON array representation of the transcripts
+      def format_transcripts(transcripts, **options)
+        data = transcripts.map(&:to_raw_data)
+        JSON.generate(data, options)
+      end
+    end
+
+    # Formats transcript as plain text (text only, no timestamps)
+    class TextFormatter < Formatter
+      # Format a single transcript as plain text
+      #
+      # @param transcript [FetchedTranscript] The transcript to format
+      # @param options [Hash] Unused options
+      # @return [String] Plain text with each line separated by newlines
+      def format_transcript(transcript, **options)
+        transcript.map(&:text).join("\n")
+      end
+
+      # Format multiple transcripts as plain text
+      #
+      # @param transcripts [Array<FetchedTranscript>] The transcripts to format
+      # @param options [Hash] Unused options
+      # @return [String] Plain text with transcripts separated by triple newlines
+      def format_transcripts(transcripts, **options)
+        transcripts.map { |t| format_transcript(t, **options) }.join("\n\n\n")
+      end
+    end
+
+    # Base class for timestamp-based formatters (SRT, WebVTT)
+    class TextBasedFormatter < TextFormatter
+      # Format a single transcript with timestamps
+      #
+      # @param transcript [FetchedTranscript] The transcript to format
+      # @param options [Hash] Unused options
+      # @return [String] Formatted transcript with timestamps
+      def format_transcript(transcript, **options)
+        lines = []
+        snippets = transcript.to_a
+
+        snippets.each_with_index do |snippet, i|
+          end_time = snippet.start + snippet.duration
+
+          # Use next snippet's start time if it starts before current end time
+          end_time = snippets[i + 1].start if i < snippets.length - 1 && snippets[i + 1].start < end_time
+
+          time_text = "#{seconds_to_timestamp(snippet.start)} --> #{seconds_to_timestamp(end_time)}"
+          lines << format_transcript_helper(i, time_text, snippet)
+        end
+
+        format_transcript_header(lines)
+      end
+
+      protected
+
+      # Format a timestamp from components
+      #
+      # @param hours [Integer] Hours component
+      # @param mins [Integer] Minutes component
+      # @param secs [Integer] Seconds component
+      # @param ms [Integer] Milliseconds component
+      # @return [String] Formatted timestamp
+      def format_timestamp(hours, mins, secs, ms)
+        raise NotImplementedError, "Subclass must implement #format_timestamp"
+      end
+
+      # Format the transcript header/wrapper
+      #
+      # @param lines [Array<String>] The formatted lines
+      # @return [String] The complete formatted transcript
+      def format_transcript_header(lines)
+        raise NotImplementedError, "Subclass must implement #format_transcript_header"
+      end
+
+      # Format a single transcript entry
+      #
+      # @param index [Integer] The entry index (0-based)
+      # @param time_text [String] The formatted time range
+      # @param snippet [TranscriptSnippet] The snippet to format
+      # @return [String] The formatted entry
+      def format_transcript_helper(index, time_text, snippet)
+        raise NotImplementedError, "Subclass must implement #format_transcript_helper"
+      end
+
+      private
+
+      # Convert seconds to timestamp string
+      #
+      # @param time [Float] Time in seconds
+      # @return [String] Formatted timestamp
+      def seconds_to_timestamp(time)
+        time = time.to_f
+        hours, remainder = time.divmod(3600)
+        mins, secs_float = remainder.divmod(60)
+        secs = secs_float.to_i
+        ms = ((time - time.to_i) * 1000).round
+
+        format_timestamp(hours.to_i, mins.to_i, secs, ms)
+      end
+    end
+
+    # Formats transcript as SRT (SubRip) subtitle format
+    #
+    # @example SRT format
+    #   1
+    #   00:00:00,000 --> 00:00:02,500
+    #   Hello world
+    #
+    #   2
+    #   00:00:02,500 --> 00:00:05,000
+    #   This is a test
+    #
+    class SRTFormatter < TextBasedFormatter
+      protected
+
+      def format_timestamp(hours, mins, secs, ms)
+        format("%02d:%02d:%02d,%03d", hours, mins, secs, ms)
+      end
+
+      def format_transcript_header(lines)
+        "#{lines.join("\n\n")}\n"
+      end
+
+      def format_transcript_helper(index, time_text, snippet)
+        "#{index + 1}\n#{time_text}\n#{snippet.text}"
+      end
+    end
+
+    # Formats transcript as WebVTT (Web Video Text Tracks) format
+    #
+    # @example WebVTT format
+    #   WEBVTT
+    #
+    #   00:00:00.000 --> 00:00:02.500
+    #   Hello world
+    #
+    #   00:00:02.500 --> 00:00:05.000
+    #   This is a test
+    #
+    class WebVTTFormatter < TextBasedFormatter
+      protected
+
+      def format_timestamp(hours, mins, secs, ms)
+        format("%02d:%02d:%02d.%03d", hours, mins, secs, ms)
+      end
+
+      def format_transcript_header(lines)
+        "WEBVTT\n\n#{lines.join("\n\n")}\n"
+      end
+
+      def format_transcript_helper(index, time_text, snippet)
+        "#{time_text}\n#{snippet.text}"
+      end
+    end
+
+    # Utility class to load formatters by type name
+    class FormatterLoader
+      # Mapping of format names to formatter classes
+      TYPES = {
+        "json" => JSONFormatter,
+        "pretty" => PrettyPrintFormatter,
+        "text" => TextFormatter,
+        "webvtt" => WebVTTFormatter,
+        "srt" => SRTFormatter
+      }.freeze
+
+      # Error raised when an unknown formatter type is requested
+      class UnknownFormatterType < StandardError
+        def initialize(formatter_type)
+          super(
+            "The format '#{formatter_type}' is not supported. " \
+            "Choose one of the following formats: #{TYPES.keys.join(', ')}"
+          )
+        end
+      end
+
+      # Load a formatter by type name
+      #
+      # @param formatter_type [String] The formatter type (json, pretty, text, webvtt, srt)
+      # @return [Formatter] An instance of the requested formatter
+      # @raise [UnknownFormatterType] If the formatter type is not supported
+      #
+      # @example
+      #   loader = FormatterLoader.new
+      #   formatter = loader.load("json")
+      #   output = formatter.format_transcript(transcript)
+      #
+      def load(formatter_type = "pretty")
+        formatter_type = formatter_type.to_s
+        raise UnknownFormatterType, formatter_type unless TYPES.key?(formatter_type)
+
+        TYPES[formatter_type].new
+      end
+    end
+  end
+end