RubyGems - youtube-rb - Versions diffs - 0.2.0 - Mend

youtube-rb 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

checksums.yaml +7 -0
data/LICENSE +21 -0
data/README.md +703 -0
data/Rakefile +6 -0
data/bin/console +10 -0
data/bin/setup +8 -0
data/lib/youtube-rb/client.rb +160 -0
data/lib/youtube-rb/downloader.rb +632 -0
data/lib/youtube-rb/extractor.rb +425 -0
data/lib/youtube-rb/options.rb +186 -0
data/lib/youtube-rb/version.rb +3 -0
data/lib/youtube-rb/video_info.rb +179 -0
data/lib/youtube-rb/ytdlp_wrapper.rb +269 -0
data/lib/youtube-rb.rb +69 -0
data/spec/client_spec.rb +514 -0
data/spec/download_with_mocks_spec.rb +216 -0
data/spec/downloader_spec.rb +774 -0
data/spec/fixtures/first_video_info.json +19 -0
data/spec/fixtures/rickroll_full_info.json +73 -0
data/spec/fixtures/rickroll_info.json +73 -0
data/spec/fixtures/rickroll_segment_info.json +9 -0
data/spec/integration/ytdlp_integration_spec.rb +109 -0
data/spec/real_download_spec.rb +175 -0
data/spec/spec_helper.rb +31 -0
data/spec/support/fixtures_helper.rb +109 -0
data/spec/support/mocking_helper.rb +21 -0
data/spec/support/webmock_helper.rb +132 -0
data/spec/youtube_rb_spec.rb +200 -0
data/spec/ytdlp_wrapper_spec.rb +178 -0
data/youtube-rb.gemspec +39 -0
metadata +229 -0

data/spec/support/webmock_helper.rb ADDED Viewed

@@ -0,0 +1,132 @@
+module WebmockHelper
+  # Stub YouTube page request
+  def stub_youtube_page(video_id, video_data)
+    # Stub the main video page
+    url = "https://www.youtube.com/watch?v=#{video_id}"
+    # Also stub various YouTube URL formats
+    stub_youtube_url_variant("https://www.youtube.com/watch?v=#{video_id}", video_id, video_data)
+    stub_youtube_url_variant("https://youtu.be/#{video_id}", video_id, video_data)
+    stub_youtube_url_variant("https://www.youtube.com/embed/#{video_id}", video_id, video_data)
+  end
+  def stub_youtube_url_variant(url, video_id, video_data)
+    # Create a fake YouTube page HTML with player response
+    player_response = {
+      'videoDetails' => {
+        'videoId' => video_data['id'],
+        'title' => video_data['title'],
+        'shortDescription' => video_data['description'],
+        'lengthSeconds' => video_data['duration'].to_s,
+        'viewCount' => video_data['view_count'].to_s,
+        'author' => video_data['uploader'],
+        'channelId' => video_data['uploader_id']
+      },
+      'streamingData' => {
+        'formats' => video_data['formats'].map { |f| format_to_player_format(f) }
+      },
+      'captions' => {
+        'playerCaptionsTracklistRenderer' => {
+          'captionTracks' => subtitles_to_caption_tracks(video_data['subtitles'])
+        }
+      },
+      'microformat' => {
+        'playerMicroformatRenderer' => {
+          'title' => video_data['title'],
+          'description' => video_data['description'],
+          'uploadDate' => format_upload_date(video_data['upload_date']),
+          'ownerChannelName' => video_data['uploader'],
+          'externalChannelId' => video_data['uploader_id'],
+          'thumbnail' => {
+            'thumbnails' => [
+              { 'url' => video_data['thumbnail'] }
+            ]
+          }
+        }
+      }
+    }
+    html = <<~HTML
+      <!DOCTYPE html>
+      <html>
+      <head><title>#{video_data['title']}</title></head>
+      <body>
+        <script>
+          var ytInitialPlayerResponse = #{player_response.to_json};
+        </script>
+      </body>
+      </html>
+    HTML
+    stub_request(:get, url)
+      .to_return(status: 200, body: html, headers: { 'Content-Type' => 'text/html' })
+  end
+  # Stub video download
+  def stub_video_download(url, content = nil)
+    content ||= sample_video_binary
+    # Stub both with and without Range header
+    stub_request(:get, url)
+      .to_return(status: 200, body: content, headers: { 'Content-Type' => 'video/mp4' })
+    # Also stub all example.com video URLs
+    stub_request(:get, /example\.com\/video.*\.mp4/)
+      .to_return(status: 200, body: content, headers: { 'Content-Type' => 'video/mp4' })
+  end
+  # Stub subtitle download
+  def stub_subtitle_download(url, content = nil)
+    content ||= sample_subtitle_vtt
+    stub_request(:get, url)
+      .to_return(status: 200, body: content, headers: { 'Content-Type' => 'text/vtt' })
+  end
+  # Stub thumbnail download
+  def stub_thumbnail_download(url, content = nil)
+    content ||= "\xFF\xD8\xFF\xE0" # JPEG header
+    stub_request(:get, url)
+      .to_return(status: 200, body: content, headers: { 'Content-Type' => 'image/jpeg' })
+  end
+  private
+  def format_to_player_format(format)
+    {
+      'itag' => format['format_id'].to_i,
+      'url' => format['url'],
+      'mimeType' => "video/#{format['ext']}; codecs=\"#{format['vcodec']}, #{format['acodec']}\"",
+      'width' => format['width'],
+      'height' => format['height'],
+      'quality' => format['quality'],
+      'qualityLabel' => "#{format['height']}p",
+      'bitrate' => format['tbr'] ? format['tbr'] * 1000 : nil
+    }
+  end
+  def subtitles_to_caption_tracks(subtitles)
+    return [] unless subtitles
+    subtitles.flat_map do |lang, subs|
+      subs.map do |sub|
+        {
+          'languageCode' => lang,
+          'baseUrl' => sub['url'],
+          'name' => { 'simpleText' => sub['name'] }
+        }
+      end
+    end
+  end
+  def format_upload_date(date_str)
+    return nil unless date_str
+    # Convert YYYYMMDD to YYYY-MM-DD
+    "#{date_str[0..3]}-#{date_str[4..5]}-#{date_str[6..7]}"
+  end
+end
+RSpec.configure do |config|
+  config.include WebmockHelper
+end

data/spec/youtube_rb_spec.rb ADDED Viewed

@@ -0,0 +1,200 @@
+RSpec.describe YoutubeRb do
+  it "has a version number" do
+    expect(YoutubeRb::VERSION).not_to be nil
+  end
+  describe ".new" do
+    it "creates a client instance" do
+      client = YoutubeRb.new
+      expect(client).to be_a(YoutubeRb::Client)
+    end
+    it "accepts options" do
+      client = YoutubeRb.new(output_path: './test')
+      expect(client.options.output_path).to eq('./test')
+    end
+  end
+  describe YoutubeRb::Client do
+    let(:client) { YoutubeRb::Client.new(output_path: './test_downloads') }
+    describe "#initialize" do
+      it "creates options from hash" do
+        expect(client.options).to be_a(YoutubeRb::Options)
+        expect(client.options.output_path).to eq('./test_downloads')
+      end
+    end
+    describe "#check_dependencies" do
+      it "returns hash with dependency status" do
+        deps = client.check_dependencies
+        expect(deps).to be_a(Hash)
+        expect(deps).to have_key(:ffmpeg)
+        expect(deps).to have_key(:ytdlp)
+        expect(deps).to have_key(:ytdlp_version)
+      end
+      it "checks ffmpeg availability" do
+        deps = client.check_dependencies
+        expect([true, false]).to include(deps[:ffmpeg])
+      end
+      it "checks yt-dlp availability" do
+        deps = client.check_dependencies
+        expect([true, false]).to include(deps[:ytdlp])
+      end
+    end
+    describe "#version" do
+      it "returns version string" do
+        expect(client.version).to eq(YoutubeRb::VERSION)
+      end
+    end
+  end
+  describe YoutubeRb::Options do
+    describe "#initialize" do
+      it "creates with default options" do
+        options = YoutubeRb::Options.new
+        expect(options.format).to eq('best')
+        expect(options.quality).to eq('best')
+        expect(options.output_path).to eq('./downloads')
+        expect(options.use_ytdlp).to eq(false)
+        expect(options.ytdlp_fallback).to eq(true)
+        expect(options.verbose).to eq(false)
+      end
+      it "creates with custom options" do
+        options = YoutubeRb::Options.new(
+          format: '1080p',
+          output_path: '/tmp',
+          write_subtitles: true,
+          use_ytdlp: true,
+          verbose: true
+        )
+        expect(options.format).to eq('1080p')
+        expect(options.output_path).to eq('/tmp')
+        expect(options.write_subtitles).to eq(true)
+        expect(options.use_ytdlp).to eq(true)
+        expect(options.verbose).to eq(true)
+      end
+    end
+    describe "#to_h" do
+      it "returns hash representation" do
+        options = YoutubeRb::Options.new(format: 'best', use_ytdlp: true)
+        hash = options.to_h
+        expect(hash).to be_a(Hash)
+        expect(hash[:format]).to eq('best')
+        expect(hash[:use_ytdlp]).to eq(true)
+        expect(hash).to have_key(:ytdlp_fallback)
+        expect(hash).to have_key(:verbose)
+      end
+    end
+    describe "#merge" do
+      it "merges options" do
+        options = YoutubeRb::Options.new(format: 'best')
+        options.merge(format: '720p', quality: 'high')
+        expect(options.format).to eq('720p')
+        expect(options.quality).to eq('high')
+      end
+    end
+  end
+  describe YoutubeRb::VideoInfo do
+    let(:video_data) do
+      {
+        'id' => 'test123',
+        'title' => 'Test Video',
+        'description' => 'Test description',
+        'duration' => 180,
+        'view_count' => 1000,
+        'formats' => [
+          {
+            'format_id' => '18',
+            'ext' => 'mp4',
+            'height' => 360,
+            'vcodec' => 'avc1',
+            'acodec' => 'mp4a'
+          }
+        ],
+        'subtitles' => {
+          'en' => [{ 'ext' => 'srt', 'url' => 'https://example.com/sub.srt' }]
+        }
+      }
+    end
+    let(:video_info) { YoutubeRb::VideoInfo.new(video_data) }
+    describe "#initialize" do
+      it "parses video data" do
+        expect(video_info.id).to eq('test123')
+        expect(video_info.title).to eq('Test Video')
+        expect(video_info.duration).to eq(180)
+        expect(video_info.view_count).to eq(1000)
+      end
+    end
+    describe "#duration_formatted" do
+      it "formats duration" do
+        expect(video_info.duration_formatted).to eq('03:00')
+      end
+      it "formats duration with hours" do
+        info = YoutubeRb::VideoInfo.new('duration' => 3665)
+        expect(info.duration_formatted).to eq('01:01:05')
+      end
+    end
+    describe "#available_formats" do
+      it "returns format IDs" do
+        expect(video_info.available_formats).to eq(['18'])
+      end
+    end
+    describe "#available_subtitle_languages" do
+      it "returns subtitle languages" do
+        expect(video_info.available_subtitle_languages).to eq(['en'])
+      end
+    end
+    describe "#to_h" do
+      it "returns hash representation" do
+        hash = video_info.to_h
+        expect(hash).to be_a(Hash)
+        expect(hash[:id]).to eq('test123')
+        expect(hash[:title]).to eq('Test Video')
+      end
+    end
+  end
+  describe YoutubeRb::Extractor do
+    let(:extractor) { YoutubeRb::Extractor.new('https://www.youtube.com/watch?v=test') }
+    describe "#initialize" do
+      it "creates extractor with URL" do
+        expect(extractor.url).to eq('https://www.youtube.com/watch?v=test')
+      end
+    end
+  end
+  describe YoutubeRb::Downloader do
+    let(:url) { 'https://www.youtube.com/watch?v=test' }
+    let(:options) { YoutubeRb::Options.new(output_path: './test_downloads') }
+    let(:downloader) { YoutubeRb::Downloader.new(url, options) }
+    describe "#initialize" do
+      it "creates downloader with URL and options" do
+        expect(downloader.url).to eq(url)
+        expect(downloader.options).to be_a(YoutubeRb::Options)
+      end
+      it "accepts hash options" do
+        dl = YoutubeRb::Downloader.new(url, { output_path: './test' })
+        expect(dl.options).to be_a(YoutubeRb::Options)
+        expect(dl.options.output_path).to eq('./test')
+      end
+    end
+  end
+end

data/spec/ytdlp_wrapper_spec.rb ADDED Viewed

@@ -0,0 +1,178 @@
+RSpec.describe YoutubeRb::YtdlpWrapper do
+  describe ".available?" do
+    it "returns boolean" do
+      result = described_class.available?
+      expect([true, false]).to include(result)
+    end
+  end
+  describe ".version" do
+    it "returns version string" do
+      version = described_class.version
+      expect(version).to be_a(String)
+      expect(version).not_to be_empty
+    end
+    it "returns 'not installed' when yt-dlp command fails" do
+      allow(Open3).to receive(:capture2).with('yt-dlp', '--version').and_raise(Errno::ENOENT)
+      version = described_class.version
+      expect(version).to eq('not installed')
+    end
+  end
+  context "when yt-dlp is available", if: YoutubeRb::YtdlpWrapper.available? do
+    let(:options) { YoutubeRb::Options.new }
+    let(:wrapper) { described_class.new(options) }
+    describe "#initialize" do
+      it "creates wrapper with options" do
+        expect(wrapper.options).to be_a(YoutubeRb::Options)
+      end
+      it "accepts hash options" do
+        wrapper = described_class.new(output_path: './test')
+        expect(wrapper.options).to be_a(YoutubeRb::Options)
+      end
+    end
+    describe "#extract_info" do
+      it "extracts video information", :slow do
+        # Note: This test requires internet and may need cookies for some videos
+        # Skip if not running integration tests
+        skip "Requires internet and may need cookies" unless ENV['RUN_INTEGRATION_TESTS']
+        url = 'https://www.youtube.com/watch?v=jNQXAC9IVRw'
+        info = wrapper.extract_info(url)
+        expect(info).to be_a(Hash)
+        expect(info).to have_key('id')
+        expect(info).to have_key('title')
+        expect(info).to have_key('duration')
+        expect(info['id']).to eq('jNQXAC9IVRw')
+      end
+      it "raises error for invalid URL" do
+        expect {
+          wrapper.extract_info('https://www.youtube.com/watch?v=invalidvideoid')
+        }.to raise_error(YoutubeRb::YtdlpWrapper::YtdlpError)
+      end
+    end
+    describe "private methods" do
+      describe "#build_info_args" do
+        it "builds correct arguments for info extraction" do
+          url = 'https://www.youtube.com/watch?v=test'
+          args = wrapper.send(:build_info_args, url)
+          expect(args).to include('yt-dlp')
+          expect(args).to include('--dump-json')
+          expect(args).to include('--no-playlist')
+          expect(args).to include(url)
+        end
+        it "includes cookies file if specified" do
+          options = YoutubeRb::Options.new(cookies_file: './test_cookies.txt')
+          wrapper = described_class.new(options)
+          # Create temporary cookies file
+          File.write('./test_cookies.txt', 'test')
+          url = 'https://www.youtube.com/watch?v=test'
+          args = wrapper.send(:build_info_args, url)
+          expect(args).to include('--cookies')
+          expect(args).to include('./test_cookies.txt')
+          File.delete('./test_cookies.txt')
+        end
+      end
+      describe "#build_download_args" do
+        it "builds correct arguments for download" do
+          url = 'https://www.youtube.com/watch?v=test'
+          args = wrapper.send(:build_download_args, url, nil)
+          expect(args).to include('yt-dlp')
+          expect(args).to include(url)
+        end
+        it "includes output path" do
+          url = 'https://www.youtube.com/watch?v=test'
+          output = './test_output.mp4'
+          args = wrapper.send(:build_download_args, url, output)
+          expect(args).to include('-o')
+          expect(args).to include(output)
+        end
+        it "includes audio extraction options" do
+          options = YoutubeRb::Options.new(
+            extract_audio: true,
+            audio_format: 'mp3',
+            audio_quality: '192'
+          )
+          wrapper = described_class.new(options)
+          url = 'https://www.youtube.com/watch?v=test'
+          args = wrapper.send(:build_download_args, url, nil)
+          expect(args).to include('-x')
+          expect(args).to include('--audio-format')
+          expect(args).to include('mp3')
+          expect(args).to include('--audio-quality')
+          expect(args).to include('192')
+        end
+        it "includes subtitle options" do
+          options = YoutubeRb::Options.new(
+            write_subtitles: true,
+            subtitle_langs: ['en', 'ru']
+          )
+          wrapper = described_class.new(options)
+          url = 'https://www.youtube.com/watch?v=test'
+          args = wrapper.send(:build_download_args, url, nil)
+          expect(args).to include('--write-subs')
+          expect(args).to include('--sub-langs')
+          expect(args).to include('en,ru')
+        end
+      end
+      describe "#build_format_string" do
+        it "returns best format by default" do
+          format = wrapper.send(:build_format_string)
+          expect(format).to eq('bestvideo+bestaudio/best')
+        end
+        it "handles quality specifications" do
+          options = YoutubeRb::Options.new(quality: '720p')
+          wrapper = described_class.new(options)
+          format = wrapper.send(:build_format_string)
+          expect(format).to include('720')
+        end
+        it "returns worst format when requested" do
+          options = YoutubeRb::Options.new(quality: 'worst')
+          wrapper = described_class.new(options)
+          format = wrapper.send(:build_format_string)
+          expect(format).to eq('worstvideo+worstaudio/worst')
+        end
+      end
+    end
+  end
+  context "when yt-dlp is not available", unless: YoutubeRb::YtdlpWrapper.available? do
+    describe "#initialize" do
+      it "raises YtdlpNotFoundError" do
+        options = YoutubeRb::Options.new
+        expect {
+          described_class.new(options)
+        }.to raise_error(YoutubeRb::YtdlpWrapper::YtdlpNotFoundError, /yt-dlp is not installed/)
+      end
+    end
+  end
+end

data/youtube-rb.gemspec ADDED Viewed

@@ -0,0 +1,39 @@
+require_relative "lib/youtube-rb/version"
+Gem::Specification.new do |spec|
+  spec.name          = "youtube-rb"
+  spec.version       = YoutubeRb::VERSION
+  spec.authors       = ["Maxim Veysgeym"]
+  spec.email         = ["qew7777@gmail.com"]
+  spec.summary       = "A Ruby library for downloading and extracting YouTube videos and subtitles"
+  spec.description   = "A Ruby library inspired by youtube-dl for downloading videos, extracting video segments, and fetching subtitles from YouTube and other video platforms"
+  spec.homepage      = "https://github.com/Qew7/youtube-rb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.4.0"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Qew7/youtube-rb"
+  spec.metadata["changelog_uri"] = "https://github.com/Qew7/youtube-rb/blob/master/CHANGELOG.md"
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.glob("{lib,bin,spec}/**/*") + %w[README.md LICENSE Rakefile youtube-rb.gemspec]
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  # Runtime dependencies
+  spec.add_dependency "faraday", "~> 2.14"
+  spec.add_dependency "faraday-retry", "~> 2.4"
+  spec.add_dependency "nokogiri", "~> 1.19"
+  spec.add_dependency "streamio-ffmpeg", "~> 3.0"
+  spec.add_dependency "addressable", "~> 2.8"
+  spec.add_dependency "base64", "~> 0.2"
+  # Development dependencies
+  spec.add_development_dependency "bundler", ">= 2.7"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "webmock", "~> 3.26"
+  spec.add_development_dependency "vcr", "~> 6.4"
+end