rubytube 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81f3bc458444b3f15a63612fa193c5fbeb0fba3f2ca73a8b3936453fcf269d58
-  data.tar.gz: ba175f34390fd95271cacc283bec75370b543b1a0edebad81e67a4188ca94790
+  metadata.gz: 57d1f41767aaf6489fa9c4ed47e82f122da84f3bbf3d7f69821f86d7d15d4d04
+  data.tar.gz: 8c453e409b21603e87a701acba2725f56b570078d89a9e73d6a643568c6580df
 SHA512:
-  metadata.gz: 9652bd73252dee11c51d1fd322813660c447e1e9c0b6a863be9e4f277309927ff8eb4d2910a991c055c8b11db833986129e5c74988653a4b50441f2e546a5804
-  data.tar.gz: 49593099d2603a922a9db02f8147e3b69d1674af663174e4d8bb6f8e7839b7b388036072f402d053699b2aee43b5b0bb6dd1789f248f10905f5aa30615b4f1f1
+  metadata.gz: a23289c4db4a278a0c0916cb53ad910e2bb1ecab5969b7d01253a4e881b149df8e84572754c9ff21b41b89504dac0c2bfa051b309cc66fe72278880bf4cdd51e
+  data.tar.gz: 172741601630ae665a819870ecefd9a0bc908afb393c318f65eb8b28e7e8cf26d85cc20d1aba8144237abec6c9b32977b6d4a33686b6ec1b5942fd00820bac4d

data/README.md

@@ -1,5 +1,7 @@
 # RubyTube
 
+[![Gem Version](https://badge.fury.io/rb/rubytube.svg)](https://badge.fury.io/rb/rubytube)
+
 RubyTube is a Ruby implementation of the popular Python library, pytube. This library facilitates the downloading and streaming of YouTube videos, offering the robust functionality of pytube in a Ruby-friendly format.
 
 ## Installation

data/lib/rubytube/cipher.rb

@@ -5,20 +5,20 @@ module RubyTube
     def initialize(js)
       self.transform_plan = get_transform_plan(js)
 
-      var_regex = %r"^\$*\w+\W"
+      var_regex = %r{^\$*\w+\W}
       var_match = @transform_plan[0].match(var_regex)
-      
+
       if var_match.nil?
         raise "RegexMatchError, caller: __init__, pattern: #{var_regex.source}"
       end
-      
+
       var = var_match[0][0..-2]
-      
+
       self.transform_map = get_transform_map(js, var)
 
       self.js_func_patterns = [
-        %r"\w+\.(\w+)\(\w,(\d+)\)",
-        %r"\w+\[(\"\w+\")\]\(\w,(\d+)\)"
+        %r{\w+\.(\w+)\(\w,(\d+)\)},
+        %r{\w+\[("\w+")\]\(\w,(\d+)\)}
       ]
 
       self.throttling_array = get_throttling_function_array(js)
@@ -27,14 +27,14 @@ module RubyTube
 
     def calculate_n(initial_n)
       throttling_array.map! do |item|
-        item == 'b' ? initial_n : item
+        (item == "b") ? initial_n : item
       end
 
       throttling_plan.each do |step|
         curr_func = throttling_array[step[0].to_i]
 
         unless curr_func.respond_to?(:call)
-          raise ExtractError.new('calculate_n', 'curr_func')
+          raise ExtractError.new("calculate_n", "curr_func")
         end
 
         first_arg = throttling_array[step[1].to_i]
@@ -52,14 +52,14 @@ module RubyTube
     end
 
     def get_signature(ciphered_signature)
-      signature = ciphered_signature.split('')
+      signature = ciphered_signature.chars
 
       transform_plan.each do |js_func|
         name, argument = parse_function(js_func)
         signature = transform_map[name].call(signature, argument)
       end
 
-      signature.join('')
+      signature.join("")
     end
 
     private
@@ -76,24 +76,24 @@ module RubyTube
           return [fn_name, fn_arg]
         end
 
-        raise RegexMatchError.new('parse_function', 'js_func_patterns')
+        raise RegexMatchError.new("parse_function", "js_func_patterns")
       end
     end
 
     def get_initial_function_name(js)
       function_patterns = [
-        %r"\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        %r{\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
         %r'(?:\b|[^a-zA-Z0-9$])(?<sig>[a-zA-Z0-9$]{2})\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',  # noqa: E501
         %r'(?<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',  # noqa: E501
-        %r'(?<quote>["\'])signature\k<quote>\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(',
-        %r"\.sig\|\|(?<sig>[a-zA-Z0-9$]+)\(",
-        %r"yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
-        %r"\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(",  # noqa: E501
+        %r{(?<quote>["\'])signature\k<quote>\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(},
+        %r{\.sig\|\|(?<sig>[a-zA-Z0-9$]+)\(},
+        %r{yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(},  # noqa: E501
+        %r{\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?<sig>[a-zA-Z0-9$]+)\(}  # noqa: E501
       ]
 
       function_patterns.each do |pattern|
@@ -104,14 +104,14 @@ module RubyTube
         end
       end
 
-      raise RegexMatchError.new('get_initial_function_name', 'multiple')
+      raise RegexMatchError.new("get_initial_function_name", "multiple")
     end
 
     def get_transform_plan(js)
       name = Regexp.escape(get_initial_function_name(js))
-      pattern = "#{name}=function\\(\\w\\)\\{[a-z=\\.\(\"\\)]*;(.*);(?:.+)\\}"
+      pattern = "#{name}=function\\(\\w\\)\\{[a-z=\\.(\"\\)]*;(.*);(?:.+)\\}"
 
-      Utils.regex_search(pattern, js, 1).split(';')
+      Utils.regex_search(pattern, js, 1).split(";")
     end
 
     def get_transform_object(js, var)
@@ -119,20 +119,20 @@ module RubyTube
       pattern = "var #{escaped_var}={(.*?)};"
       regex = Regexp.new(pattern, Regexp::MULTILINE)
       transform_match = regex.match(js)
-      
+
       if transform_match.nil?
-        raise RegexMatchError.new('get_transform_object', pattern)
+        raise RegexMatchError.new("get_transform_object", pattern)
       end
-      
-      transform_match[1].gsub("\n", " ").split(", ")
+
+      transform_match[1].tr("\n", " ").split(", ")
     end
 
     def get_transform_map(js, var)
       transform_obejct = get_transform_object(js, var)
       mapper = {}
-      
+
       transform_obejct.each do |obj|
-        name, function = obj.split(':')
+        name, function = obj.split(":")
         fn = map_functions(function)
         mapper[name] = fn
       end
@@ -144,12 +144,12 @@ module RubyTube
       # Ruby equivalent of JavaScript's Array.reverse()
       arr.reverse!
     end
-    
+
     def splice(arr, index)
       # Ruby equivalent of JavaScript's Array.splice(0, index)
       arr.shift(index.to_i)
     end
-    
+
     def swap(arr, index)
       # Ruby equivalent of the JavaScript swapping function
       temp = arr[0]
@@ -165,7 +165,7 @@ module RubyTube
     def throttling_mod_func(d, e)
       (e % d.length + d.length) % d.length
     end
-    
+
     def throttling_unshift(d, e)
       e = throttling_mod_func(d, e)
       new_arr = d[-e..-1] + d[0...-e]
@@ -174,12 +174,12 @@ module RubyTube
     end
 
     def throttling_cipher_function(d, e)
-      h = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'.split('')
+      h = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".chars
       f = 96
-      self_arr = e.split('')
-    
+      self_arr = e.chars
+
       copied_array = d.clone
-    
+
       copied_array.each_with_index do |l, m|
         bracket_val = (h.index(l) - h.index(self_arr[m]) + m - 32 + f) % h.length
         self_arr << h[bracket_val]
@@ -204,26 +204,26 @@ module RubyTube
       d.clear.concat(new_arr)
 
       end_len = d.length
-      raise 'Length mismatch' unless start_len == end_len
+      raise "Length mismatch" unless start_len == end_len
     end
 
-    def js_splice(arr, start, delete_count=nil, *items)
+    def js_splice(arr, start, delete_count = nil, *items)
       if start.is_a? Integer
         start = arr.length if start > arr.length
         start += arr.length if start < 0
       else
         start = 0
       end
-    
+
       delete_count = arr.length - start if delete_count.nil? || delete_count >= arr.length - start
       deleted_elements = arr[start, delete_count]
-    
+
       new_arr = arr[0...start] + items + arr[(start + delete_count)..-1]
-    
+
       arr.clear.concat(new_arr)
-    
+
       deleted_elements
-    end    
+    end
 
     def map_functions(function)
       mapper = [
@@ -232,22 +232,22 @@ module RubyTube
         # function(a,b){a.splice(0,b)}
         [%r"{\w\.splice\(0,\w\)}", method(:splice)],
         # function(a,b){var c=a[0];a[0]=a[b%a.length];a[b]=c}
-        [%r"{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];\w\[\w\]=\w}", method(:swap)],
+        [%r"{var\s\w=\w\[0\];\w\[0\]=\w\[\w%\w.length\];\w\[\w\]=\w}", method(:swap)],
         # function(a,b){var c=a[0];a[0]=a[b%a.length];a[b%a.length]=c}
-        [%r"{var\s\w=\w\[0\];\w\[0\]=\w\[\w\%\w.length\];\w\[\w\%\w.length\]=\w}", method(:swap)]
+        [%r"{var\s\w=\w\[0\];\w\[0\]=\w\[\w%\w.length\];\w\[\w%\w.length\]=\w}", method(:swap)]
       ]
 
       mapper.each do |pattern, fn|
         return fn if Regexp.new(pattern).match?(function)
       end
-    
-      raise RegexMatchError.new('map_functions', 'multiple')
+
+      raise RegexMatchError.new("map_functions", "multiple")
     end
 
     def get_throttling_function_name(js)
       function_patterns = [
-        %r'a\.[a-zA-Z]\s*&&\s*\([a-z]\s*=\s*a\.get\("n"\)\)\s*&&.*?\|\|\s*([a-z]+)',
-        %r'\([a-z]\s*=\s*([a-zA-Z0-9$]+)(\[\d+\])\([a-z]\)',
+        %r{a\.[a-zA-Z]\s*&&\s*\([a-z]\s*=\s*a\.get\("n"\)\)\s*&&.*?\|\|\s*([a-z]+)},
+        %r{\([a-z]\s*=\s*([a-zA-Z0-9$]+)(\[\d+\])\([a-z]\)}
       ]
 
       function_patterns.each do |pattern|
@@ -261,23 +261,23 @@ module RubyTube
 
         idx = function_match[2]
         if idx
-          idx = idx.tr('[]', '')
+          idx = idx.tr("[]", "")
           array_match = js.match(/var #{Regexp.escape(function_match[1])}\s*=\s*(\[.+?\])/)
           if array_match
-            array = array_match[1].tr('[]', '').split(',')
+            array = array_match[1].tr("[]", "").split(",")
             array = array.map(&:strip)
             return array[idx.to_i]
           end
         end
       end
 
-      raise RegexMatchError.new('get_throttling_function_name', 'multiple')
+      raise RegexMatchError.new("get_throttling_function_name", "multiple")
     end
 
     def get_throttling_function_code(js)
       name = Regexp.escape(get_throttling_function_name(js))
 
-      pattern_start = %r"#{name}=function\(\w\)"
+      pattern_start = %r{#{name}=function\(\w\)}
       regex = Regexp.new(pattern_start)
       match = js.match(regex)
 
@@ -289,12 +289,12 @@ module RubyTube
 
     def get_throttling_function_array(js)
       raw_code = get_throttling_function_code(js)
-    
+
       array_regex = /,c=\[/
       match = raw_code.match(array_regex)
       array_raw = Parser.find_object_from_startpoint(raw_code, match.end(0) - 1)
       str_array = Parser.throttling_array_split(array_raw)
-    
+
       converted_array = []
       str_array.each do |el|
         begin
@@ -303,28 +303,28 @@ module RubyTube
         rescue ArgumentError
           # Not an integer value.
         end
-    
-        if el == 'null'
+
+        if el == "null"
           converted_array << nil
           next
         end
-    
+
         if el.start_with?('"') && el.end_with?('"')
           converted_array << el[1..-2]
           next
         end
-    
-        if el.start_with?('function')
+
+        if el.start_with?("function")
           mapper = [
             [%r"{for\(\w=\(\w%\w\.length\+\w\.length\)%\w\.length;\w--;\)\w\.unshift\(\w.pop\(\)\)}", method(:throttling_unshift)],
             [%r"{\w\.reverse\(\)}", method(:reverse)],
             [%r"{\w\.push\(\w\)}", method(:push)],
             [%r";var\s\w=\w\[0\];\w\[0\]=\w\[\w\];\w\[\w\]=\w}", method(:swap)],
-            [%r"case\s\d+", method(:throttling_cipher_function)],
-            [%r"\w\.splice\(0,1,\w\.splice\(\w,1,\w\[0\]\)\[0\]\)", method(:throttling_nested_splice)],
+            [%r{case\s\d+}, method(:throttling_cipher_function)],
+            [%r{\w\.splice\(0,1,\w\.splice\(\w,1,\w\[0\]\)\[0\]\)}, method(:throttling_nested_splice)],
             [%r";\w\.splice\(\w,1\)}", method(:js_splice)],
             [%r"\w\.splice\(-\w\)\.reverse\(\)\.forEach\(function\(\w\){\w\.unshift\(\w\)}\)", method(:throttling_prepend)],
-            [%r"for\(var \w=\w\.length;\w;\)\w\.push\(\w\.splice\(--\w,1\)\[0\]\)}", method(:reverse)],
+            [%r"for\(var \w=\w\.length;\w;\)\w\.push\(\w\.splice\(--\w,1\)\[0\]\)}", method(:reverse)]
           ]
 
           found = false
@@ -336,10 +336,10 @@ module RubyTube
           end
           next if found
         end
-    
+
         converted_array << el
       end
-    
+
       converted_array.map! { |el| el.nil? ? converted_array : el }
       converted_array
     end
@@ -351,9 +351,8 @@ module RubyTube
       plan_regex = Regexp.new(transform_start)
       match = raw_code.match(plan_regex)
 
-      # transform_plan_raw = Parser.find_object_from_startpoint(raw_code, match.end(0) - 1)
-      transform_plan_raw = js
-      step_regex = %r"c\[(\d+)\]\(c\[(\d+)\](,c(\[(\d+)\]))?\)"
+      transform_plan_raw = Parser.find_object_from_startpoint(raw_code, match.end(0) - 1)
+      step_regex = %r{c\[(\d+)\]\(c\[(\d+)\](,c(\[(\d+)\]))?\)}
       matches = transform_plan_raw.scan(step_regex)
       transform_steps = []
 

data/lib/rubytube/client.rb

@@ -33,10 +33,10 @@ module RubyTube
     end
 
     def streaming_data
-      return vid_info['streamingData'] if vid_info && vid_info.key?('streamingData')
+      return vid_info["streamingData"] if vid_info && vid_info.key?("streamingData")
 
       bypass_age_gate
-      vid_info['streamingData']
+      vid_info["streamingData"]
     end
 
     def fmt_streams
@@ -69,24 +69,24 @@ module RubyTube
 
       messages.each do |reason|
         case status
-        when 'UNPLAYABLE'
+        when "UNPLAYABLE"
           case reason
-          when 'Join this channel to get access to members-only content like this video, and other exclusive perks.'
+          when "Join this channel to get access to members-only content like this video, and other exclusive perks."
             raise MembersOnly.new(video_id)
-          when 'This live stream recording is not available.'
+          when "This live stream recording is not available."
             raise RecordingUnavailable.new(video_id)
           else
             raise VideoUnavailable.new(video_id)
           end
-        when 'LOGIN_REQUIRED'
-          if reason == 'This is a private video. Please sign in to verify that you may see it.'
+        when "LOGIN_REQUIRED"
+          if reason == "This is a private video. Please sign in to verify that you may see it."
             raise VideoPrivate.new(video_id)
           end
-        when 'ERROR'
-          if reason == 'Video unavailable'
+        when "ERROR"
+          if reason == "Video unavailable"
             raise VideoUnavailable.new(video_id)
           end
-        when 'LIVE_STREAM'
+        when "LIVE_STREAM"
           raise LiveStreamError.new(video_id)
         end
       end
@@ -100,9 +100,9 @@ module RubyTube
     end
 
     def thumbnail_url
-      thumbs = vid_info.fetch('videoDetails', {}).fetch('thumbnail', {}).fetch('thumbnails', [])
+      thumbs = vid_info.fetch("videoDetails", {}).fetch("thumbnail", {}).fetch("thumbnails", [])
 
-      return thumbs[-1]['url'] if thumbs.size > 0
+      return thumbs[-1]["url"] if thumbs.size > 0
 
       "https://img.youtube.com/vi/#{ideo_id}/maxresdefault.jpg"
     end
@@ -117,11 +117,11 @@ module RubyTube
     end
 
     def bypass_age_gate
-      it = InnerTube.new(client: 'ANDROID_EMBED')
+      it = InnerTube.new(client: "ANDROID_EMBED")
       resp = it.player(video_id)
 
-      status = resp['playabilityStatus']['status']
-      if status == 'UNPLAYABLE'
+      status = resp["playabilityStatus"]["status"]
+      if status == "UNPLAYABLE"
         raise VideoUnavailable.new(video_id)
       end
 
@@ -131,42 +131,42 @@ module RubyTube
     def title
       return @title if @title
 
-      @title = vid_info['videoDetails']['title']
+      @title = vid_info["videoDetails"]["title"]
       @title
     end
 
     def length
       return @length if @length
 
-      @length = vid_info['videoDetails']['lengthSeconds'].to_i
+      @length = vid_info["videoDetails"]["lengthSeconds"].to_i
       @length
     end
 
     def views
       return @views if @views
 
-      @views = vid_info['videoDetails']['viewCount'].to_i
+      @views = vid_info["videoDetails"]["viewCount"].to_i
       @views
     end
 
     def author
       return @author if @author
 
-      @author = vid_info['videoDetails']['author']
+      @author = vid_info["videoDetails"]["author"]
       @author
     end
 
     def keywords
       return @keywords if @keywords
 
-      @keywords = vid_info['videoDetails']['keywords']
+      @keywords = vid_info["videoDetails"]["keywords"]
       @keywords
     end
 
     def channel_id
       return @channel_id if @channel_id
 
-      @channel_id = vid_info['videoDetails']['channelId']
+      @channel_id = vid_info["videoDetails"]["channelId"]
       @channel_id
     end
   end

data/lib/rubytube/error.rb

@@ -0,0 +1,49 @@
+module RubyTube
+  class Error < StandardError; end
+
+  class HTMLParseError < StandardError; end
+
+  class ExtractError < StandardError; end
+
+  class MaxRetriesExceeded < StandardError; end
+
+  class VideoUnavailable < StandardError; end
+
+  class InvalidArgumentError < ArgumentError; end
+
+  class RegexMatchError < StandardError
+    def initialize(caller, pattern)
+      super("Regex match error in #{caller} for pattern #{pattern}")
+    end
+  end
+
+  class MembersOnly < StandardError
+    def initialize(video_id)
+      super("Members only video: #{video_id}")
+    end
+  end
+
+  class RecordingUnavailable < StandardError
+    def initialize(video_id)
+      super("Recording unavailable: #{video_id}")
+    end
+  end
+
+  class VideoUnavailable < StandardError
+    def initialize(video_id)
+      super("Video unavailable: #{video_id}")
+    end
+  end
+
+  class VideoPrivate < StandardError
+    def initialize(video_id)
+      super("Video is private: #{video_id}")
+    end
+  end
+
+  class LiveStreamError < StandardError
+    def initialize(video_id)
+      super("Video is a live stream: #{video_id}")
+    end
+  end
+end

data/lib/rubytube/extractor.rb

@@ -4,32 +4,32 @@ module RubyTube
       def playability_status(watch_html)
         player_response = initial_player_response(watch_html)
         player_response = JSON.parse(player_response)
-        status_obj = player_response['playabilityStatus'] || {}
-      
-        if status_obj.has_key?('liveStreamability')
-          return ['LIVE_STREAM', 'Video is a live stream.']
+        status_obj = player_response["playabilityStatus"] || {}
+
+        if status_obj.has_key?("liveStreamability")
+          return ["LIVE_STREAM", "Video is a live stream."]
         end
-      
-        if status_obj.has_key?('status')
-          if status_obj.has_key?('reason')
-            return [status_obj['status'], [status_obj['reason']]]
+
+        if status_obj.has_key?("status")
+          if status_obj.has_key?("reason")
+            return [status_obj["status"], [status_obj["reason"]]]
           end
-      
-          if status_obj.has_key?('messages')
-            return [status_obj['status'], status_obj['messages']]
+
+          if status_obj.has_key?("messages")
+            return [status_obj["status"], status_obj["messages"]]
           end
         end
-      
+
         [nil, [nil]]
       end
 
       def video_id(url)
-        return Utils.regex_search(/(?:v=|\/)([0-9A-Za-z_-]{11}).*/, url, 1)
+        Utils.regex_search(/(?:v=|\/)([0-9A-Za-z_-]{11}).*/, url, 1)
       end
 
       def js_url(html)
         begin
-          base_js = get_ytplayer_config(html)['assets']['js']
+          base_js = get_ytplayer_config(html)["assets"]["js"]
         rescue RegexMatchError, NoMethodError
           base_js = get_ytplayer_js(html)
         end
@@ -38,18 +38,18 @@ module RubyTube
       end
 
       def mime_type_codec(mime_type_codec)
-        pattern = %r{(\w+\/\w+)\;\scodecs=\"([a-zA-Z\-0-9.,\s]*)\"}
+        pattern = %r{(\w+/\w+);\scodecs="([a-zA-Z\-0-9.,\s]*)"}
         results = mime_type_codec.match(pattern)
-      
+
         raise RegexMatchError.new("mime_type_codec, pattern=#{pattern}") if results.nil?
-      
+
         mime_type, codecs = results.captures
         [mime_type, codecs.split(",").map(&:strip)]
       end
 
       def get_ytplayer_js(html)
         js_url_patterns = [
-          %r{(/s/player/[\w\d]+/[\w\d_/.]+/base\.js)},
+          %r{(/s/player/[\w\d]+/[\w\d_/.]+/base\.js)}
         ]
 
         js_url_patterns.each do |pattern|
@@ -59,7 +59,7 @@ module RubyTube
           end
         end
 
-        raise RegexMatchError.new('get_ytplayer_js', 'js_url_patterns')
+        raise RegexMatchError.new("get_ytplayer_js", "js_url_patterns")
       end
 
       def get_ytplayer_config(html)
@@ -69,11 +69,9 @@ module RubyTube
         ]
 
         config_patterns.each do |pattern|
-          begin
-            return Parser.parse_for_object(html, pattern)
-          rescue HTMLParseError => e
-            next
-          end
+          return Parser.parse_for_object(html, pattern)
+        rescue HTMLParseError => e
+          next
         end
 
         setconfig_patterns = [
@@ -81,14 +79,12 @@ module RubyTube
         ]
 
         setconfig_patterns.each do |pattern|
-          begin
-            return Parser.parse_for_object(html, pattern)
-          rescue HTMLParseError => e
-            next
-          end
+          return Parser.parse_for_object(html, pattern)
+        rescue HTMLParseError => e
+          next
         end
 
-        raise RegexMatchError.new('get_ytplayer_config', 'config_patterns, setconfig_patterns')
+        raise RegexMatchError.new("get_ytplayer_config", "config_patterns, setconfig_patterns")
       end
 
       def apply_signature(stream_manifest, vid_info, js)
@@ -96,33 +92,33 @@ module RubyTube
 
         stream_manifest.each_with_index do |stream, i|
           begin
-            url = stream['url']
+            url = stream["url"]
           rescue NoMethodError
-            live_stream = vid_info.fetch('playabilityStatus', {})['liveStreamability']
+            live_stream = vid_info.fetch("playabilityStatus", {})["liveStreamability"]
             if live_stream
-              raise LiveStreamError.new('UNKNOWN')
+              raise LiveStreamError.new("UNKNOWN")
             end
           end
 
-          if url.include?("signature") || 
-            (!stream.key?("s") && (url.include?("&sig=") || url.include?("&lsig=")))
+          if url.include?("signature") ||
+              (!stream.key?("s") && (url.include?("&sig=") || url.include?("&lsig=")))
             # For certain videos, YouTube will just provide them pre-signed, in
             # which case there's no real magic to download them and we can skip
             # the whole signature descrambling entirely.
             next
           end
 
-          signature = cipher.get_signature(stream['s'])
+          signature = cipher.get_signature(stream["s"])
 
           parsed_url = URI.parse(url)
 
           query_params = CGI.parse(parsed_url.query)
           query_params.transform_values!(&:first)
-          query_params['sig'] = signature
-          unless query_params.key?('ratebypass')
-            initial_n = query_params['n'].split('')
+          query_params["sig"] = signature
+          unless query_params.key?("ratebypass")
+            initial_n = query_params["n"].chars
             new_n = cipher.calculate_n(initial_n)
-            query_params['n'] = new_n
+            query_params["n"] = new_n
           end
 
           url = "#{parsed_url.scheme}://#{parsed_url.host}#{parsed_url.path}?#{URI.encode_www_form(query_params)}"
@@ -132,23 +128,23 @@ module RubyTube
       end
 
       def apply_descrambler(stream_data)
-        return if stream_data.has_key?('url')
+        return if stream_data.has_key?("url")
 
         # Merge formats and adaptiveFormats into a single array
         formats = []
-        formats += stream_data['formats'] if stream_data.has_key?('formats')
-        formats += stream_data['adaptiveFormats'] if stream_data.has_key?('adaptiveFormats')
+        formats += stream_data["formats"] if stream_data.has_key?("formats")
+        formats += stream_data["adaptiveFormats"] if stream_data.has_key?("adaptiveFormats")
 
         # Extract url and s from signatureCiphers as necessary
         formats.each do |data|
-          unless data.has_key?('url')
-            if data.has_key?('signatureCipher')
-              cipher_url = URI.decode_www_form(data['signatureCipher']).to_h
-              data['url'] = cipher_url['url']
-              data['s'] = cipher_url['s']
+          unless data.has_key?("url")
+            if data.has_key?("signatureCipher")
+              cipher_url = URI.decode_www_form(data["signatureCipher"]).to_h
+              data["url"] = cipher_url["url"]
+              data["s"] = cipher_url["s"]
             end
           end
-          data['is_otf'] = data['type'] == 'FORMAT_STREAM_TYPE_OTF'
+          data["is_otf"] = data["type"] == "FORMAT_STREAM_TYPE_OTF"
         end
 
         formats
@@ -161,16 +157,14 @@ module RubyTube
           "window\\[['\"]ytInitialPlayerResponse['\"]\\]\\s*=\\s*",
           "ytInitialPlayerResponse\\s*=\\s*"
         ]
-      
+
         patterns.each do |pattern|
-          begin
-            return Parser.parse_for_object(watch_html, pattern)
-          rescue HTMLParseError
-            next
-          end
+          return Parser.parse_for_object(watch_html, pattern)
+        rescue HTMLParseError
+          next
         end
-      
-        raise RegexMatchError.new('initial_player_response', 'initial_player_response_pattern')
+
+        raise RegexMatchError.new("initial_player_response", "initial_player_response_pattern")
       end
     end
   end

data/lib/rubytube/innertube.rb

@@ -1,55 +1,55 @@
 module RubyTube
   class InnerTube
     DEFALUT_CLIENTS = {
-      'WEB' => {
+      "WEB" => {
         context: {
           client: {
-            clientName: 'WEB',
-            clientVersion: '2.20200720.00.02'
+            clientName: "WEB",
+            clientVersion: "2.20200720.00.02"
           }
         },
-        header: { 'User-Agent': 'Mozilla/5.0' },
-        api_key: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
+        header: {"User-Agent": "Mozilla/5.0"},
+        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
       },
-      'ANDROID_MUSIC' => {
+      "ANDROID_MUSIC" => {
         context: {
           client: {
-            clientName: 'ANDROID_MUSIC',
-            clientVersion: '5.16.51',
-            androidSdkVersion: 30,
-          },
+            clientName: "ANDROID_MUSIC",
+            clientVersion: "5.16.51",
+            androidSdkVersion: 30
+          }
         },
-        header: { 'User-Agent': 'com.google.android.apps.youtube.music/'},
-        api_key: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
+        header: {"User-Agent": "com.google.android.apps.youtube.music/"},
+        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
       },
-      'ANDROID_EMBED' => {
+      "ANDROID_EMBED" => {
         context: {
-            client: {
-                clientName: 'ANDROID_EMBEDDED_PLAYER',
-                clientVersion: '17.31.35',
-                clientScreen: 'EMBED',
-                androidSdkVersion: 30,
-            }
+          client: {
+            clientName: "ANDROID_EMBEDDED_PLAYER",
+            clientVersion: "17.31.35",
+            clientScreen: "EMBED",
+            androidSdkVersion: 30
+          }
         },
-        header: { 'User-Agent': 'com.google.android.youtube/' },
-        api_key: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
-      },
+        header: {"User-Agent": "com.google.android.youtube/"},
+        api_key: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8"
+      }
     }
 
-    BASE_URL = 'https://www.youtube.com/youtubei/v1'
+    BASE_URL = "https://www.youtube.com/youtubei/v1"
 
     attr_accessor :context, :header, :api_key, :access_token, :refresh_token, :use_oauth, :allow_cache, :expires
 
-    def initialize(client: 'ANDROID_MUSIC', use_oauth: false, allow_cache: false)
+    def initialize(client: "WEB", use_oauth: false, allow_cache: false)
       self.context = DEFALUT_CLIENTS[client][:context]
-      self.header  = DEFALUT_CLIENTS[client][:header]
+      self.header = DEFALUT_CLIENTS[client][:header]
       self.api_key = DEFALUT_CLIENTS[client][:api_key]
       self.use_oauth = use_oauth
       self.allow_cache = allow_cache
     end
 
     def cache_tokens
-      return unless allow_cache
+      nil unless allow_cache
 
       # TODO:
     end
@@ -68,16 +68,16 @@ module RubyTube
       end
 
       headers = {
-        'Content-Type': 'application/json',
+        "Content-Type": "application/json"
       }
 
       if use_oauth
         if access_token
           refresh_bearer_token
-          headers['Authorization'] = "Bearer #{access_token}"
+          headers["Authorization"] = "Bearer #{access_token}"
         else
           fetch_bearer_token
-          headers['Authorization'] = "Bearer #{access_token}"
+          headers["Authorization"] = "Bearer #{access_token}"
         end
       end
 
@@ -87,7 +87,7 @@ module RubyTube
       options[:query] = {
         key: api_key,
         contentCheckOk: true,
-        racyCheckOk: true,
+        racyCheckOk: true
       }.merge(query)
       options[:data] = data
 
@@ -97,7 +97,7 @@ module RubyTube
 
     def player(video_id)
       endpoint = "#{BASE_URL}/player"
-      query = { 'videoId' => video_id }
+      query = {"videoId" => video_id}
 
       send(endpoint, query, {context: context})
     end

data/lib/rubytube/parser.rb

@@ -11,31 +11,31 @@ module RubyTube
       end
       start_index = result.end(0)
 
-      return parse_for_object_from_startpoint(html, start_index)
+      parse_for_object_from_startpoint(html, start_index)
     end
 
     def find_object_from_startpoint(html, start_point)
       html = html[start_point..-1]
-      unless ['{', '['].include?(html[0])
+      unless ["{", "["].include?(html[0])
         raise HTMLParseError, "Invalid start point. Start of HTML:\n#{html[0..19]}"
       end
 
-      last_char = '{'
+      last_char = "{"
       curr_char = nil
       stack = [html[0]]
       i = 1
 
       context_closers = {
-        '{' => '}',
-        '[' => ']',
+        "{" => "}",
+        "[" => "]",
         '"' => '"',
-        '/' => '/',
+        "/" => "/"
       }
 
       while i < html.length
         break if stack.empty?
 
-        last_char = curr_char unless [' ', '\n'].include?(curr_char)
+        last_char = curr_char unless [" ", '\n'].include?(curr_char)
         curr_char = html[i]
         curr_context = stack.last
 
@@ -45,54 +45,52 @@ module RubyTube
           next
         end
 
-        if ['"', '/'].include?(curr_context)
-          if curr_char == '\\'
+        if ['"', "/"].include?(curr_context)
+          if curr_char == "\\"
             i += 2
             next
           end
-        else
-          if context_closers.keys.include?(curr_char)
-            unless curr_char == '/' && !['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';'].include?(last_char)
-              stack.push(curr_char)
-            end
+        elsif context_closers.keys.include?(curr_char)
+          unless curr_char == "/" && !["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";"].include?(last_char)
+            stack.push(curr_char)
           end
         end
 
         i += 1
       end
 
-      full_obj = html[0...i]
-      full_obj
+      html[0...i]
     end
 
     def parse_for_object_from_startpoint(html, start_point)
       html = html[start_point..-1]
 
-      unless ['{', '['].include?(html[0])
+      unless ["{", "["].include?(html[0])
         raise HTMLParseError, "Invalid start point. Start of HTML:\n#{html[0..19]}"
       end
 
       # First letter MUST be an open brace, so we put that in the stack,
       # and skip the first character.
-      last_char = '{'
+      last_char = "{"
       curr_char = nil
       stack = [html[0]]
       i = 1
 
       context_closers = {
-        '{' => '}',
-        '[' => ']',
+        "{" => "}",
+        "[" => "]",
         '"' => '"',
-        '/' => '/' # JavaScript regex
+        :"'" => "'",
+        "/" => "/" # JavaScript regex
       }
 
       while i < html.length
         break if stack.empty?
-    
-        last_char = curr_char unless [' ', '\n'].include?(curr_char)
+
+        last_char = curr_char unless [" ", '\n'].include?(curr_char)
         curr_char = html[i]
         curr_context = stack.last
-    
+
         # If we've reached a context closer, we can remove an element off the stack
         if curr_char == context_closers[curr_context]
           stack.pop
@@ -101,42 +99,39 @@ module RubyTube
         end
         # Strings and regex expressions require special context handling because they can contain
         # context openers *and* closers
-        if ['"', '/'].include?(curr_context)
+        if ['"', "/"].include?(curr_context)
           # If there's a backslash in a string or regex expression, we skip a character
-          if curr_char == '\\'
+          if curr_char == "\\"
             i += 2
             next
           end
-        else
+        elsif context_closers.keys.include?(curr_char)
           # Non-string contexts are when we need to look for context openers.
-          if context_closers.keys.include?(curr_char)
-            # Slash starts a regular expression depending on context
-            unless curr_char == '/' && ['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';'].include?(last_char)
-              stack << curr_char
-            end
+          unless curr_char == "/" && ["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";"].include?(last_char)
+            stack << curr_char
           end
+          # Slash starts a regular expression depending on context
         end
 
         i += 1
       end
 
-      full_obj = html[0..(i - 1)]
-      full_obj
+      html[0..(i - 1)]
     end
 
     def throttling_array_split(js_array)
       results = []
       curr_substring = js_array[1..-1]
-    
+
       comma_regex = /,/
       func_regex = /function\([^)]*\)/
-    
+
       until curr_substring.empty?
-        if curr_substring.start_with?('function')
+        if curr_substring.start_with?("function")
           match = func_regex.match(curr_substring)
           match_start = match.begin(0)
           match_end = match.end(0)
-    
+
           function_text = find_object_from_startpoint(curr_substring, match_end)
           full_function_def = curr_substring[0, match_end + function_text.length]
           results << full_function_def
@@ -151,13 +146,13 @@ module RubyTube
             match_start = curr_substring.length - 1
             match_end = match_start + 1
           end
-    
+
           curr_el = curr_substring[0, match_start]
           results << curr_el
           curr_substring = curr_substring[match_end..-1]
         end
       end
-    
+
       results
     end
   end

data/lib/rubytube/request.rb

@@ -24,7 +24,7 @@ module RubyTube
         stop_pos = [downloaded + DEFAULT_RANGE_SIZE, file_size].min - 1
         range_header = "bytes=#{downloaded}-#{stop_pos}"
         tries = 0
-    
+
         while true
           begin
             if tries >= 1 + max_retries
@@ -56,20 +56,18 @@ module RubyTube
     end
 
     def send(method, url, options = {})
-      headers = { 'Content-Type': 'text/html' }
+      headers = {"Content-Type": "text/html"}
       options[:headers] && headers.merge!(options[:headers])
 
       connection = Faraday.new(url: url) do |faraday|
         faraday.response :follow_redirects
         faraday.adapter Faraday.default_adapter
       end
-      response = connection.send(method) do |req|
+      connection.send(method) do |req|
         req.headers = headers
-        options[:query] && req.params = options[:query] 
+        options[:query] && req.params = options[:query]
         options[:data] && req.body = JSON.dump(options[:data])
       end
-
-      response
     end
   end
 end

data/lib/rubytube/stream.rb

@@ -16,16 +16,16 @@ module RubyTube
     def initialize(stream, monostate)
       self.monostate = monostate
 
-      self.url = stream['url']
-      self.itag = stream['itag'].to_i
+      self.url = stream["url"]
+      self.itag = stream["itag"].to_i
 
-      self.mime_type, self.codecs = Extractor.mime_type_codec(stream['mimeType'])
-      self.type, self.subtype = mime_type.split('/')
+      self.mime_type, self.codecs = Extractor.mime_type_codec(stream["mimeType"])
+      self.type, self.subtype = mime_type.split("/")
 
-      self.is_otf = stream['is_otf']
-      self.bitrate = stream['bitrate']
+      self.is_otf = stream["is_otf"]
+      self.bitrate = stream["bitrate"]
 
-      self.file_size = stream.fetch('contentLength', 0).to_i
+      self.file_size = stream.fetch("contentLength", 0).to_i
     end
 
     def download(filename: nil, output_dir: nil)
@@ -35,26 +35,24 @@ module RubyTube
 
       bytes_remaining = file_size
 
-      File.open(file_path, 'wb') do |f|
-        begin
-          Request.stream(url) do |chunk|
-            bytes_remaining -= chunk.bytesize
-            f.write(chunk)
-          end
-        rescue HTTPError => e
-          raise e if e.code != 404
+      File.open(file_path, "wb") do |f|
+        Request.stream(url) do |chunk|
+          bytes_remaining -= chunk.bytesize
+          f.write(chunk)
         end
+      rescue HTTPError => e
+        raise e if e.code != 404
       end
 
       file_path
     end
 
     def is_audio?
-      type == 'audio'
+      type == "audio"
     end
 
     def is_video?
-      type == 'video'
+      type == "video"
     end
 
     def is_adaptive?
@@ -75,8 +73,8 @@ module RubyTube
 
     private
 
-    def get_file_path(filename, output_dir, prefix = '')
-      filename = default_filename unless filename
+    def get_file_path(filename, output_dir, prefix = "")
+      filename ||= default_filename
 
       if prefix
         filename = "#{prefix}#{filename}"

data/lib/rubytube/stream_format.rb

@@ -34,7 +34,7 @@ module RubyTube
       132 => ["240p", "48kbps"],
       151 => ["720p", "24kbps"],
       300 => ["720p", "128kbps"],
-      301 => ["1080p", "128kbps"],
+      301 => ["1080p", "128kbps"]
     }
 
     DASH_VIDEO = {
@@ -112,7 +112,7 @@ module RubyTube
       256 => [nil, "192kbps"],
       258 => [nil, "384kbps"],
       325 => [nil, nil],
-      328 => [nil, nil],
+      328 => [nil, nil]
     }
 
     ITAGS = {

data/lib/rubytube/stream_query.rb

@@ -33,6 +33,10 @@ module RubyTube
       streams.find { |s| s.resolution == resolution }
     end
 
+    def get_highest_resolution
+      order(resolution: :desc).first
+    end
+
     def order(arg)
       case arg
       when Symbol
@@ -40,14 +44,14 @@ module RubyTube
         dir = :asc
       when Hash
         field = arg.keys.first
-        dir = arg[field] == :desc ? :desc : :asc
+        dir = (arg[field] == :desc) ? :desc : :asc
       end
 
       allowed_fields = [:file_size, :itag, :resolution]
       raise InvalidArgumentError unless allowed_fields.include? field
 
       r = streams
-      r.sort! {|a, b| a.send(field).to_i <=> b.send(field).to_i }
+      r.sort! { |a, b| a.send(field).to_i <=> b.send(field).to_i }
 
       r.reverse! if dir == :desc
 

data/lib/rubytube/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyTube
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/rubytube.rb

@@ -1,66 +1,24 @@
 # frozen_string_literal: true
 
-require 'faraday'
-require 'faraday/follow_redirects'
+require "faraday"
+require "faraday/follow_redirects"
 
-require_relative 'rubytube/version'
+require_relative "rubytube/version"
 
-require_relative 'rubytube/cipher'
-require_relative 'rubytube/client'
-require_relative 'rubytube/extractor'
-require_relative 'rubytube/innertube'
-require_relative 'rubytube/monostate'
-require_relative 'rubytube/parser'
-require_relative 'rubytube/request'
-require_relative 'rubytube/stream_format'
-require_relative 'rubytube/stream_query'
-require_relative 'rubytube/stream'
-require_relative 'rubytube/utils'
+require_relative "rubytube/cipher"
+require_relative "rubytube/client"
+require_relative "rubytube/error"
+require_relative "rubytube/extractor"
+require_relative "rubytube/innertube"
+require_relative "rubytube/monostate"
+require_relative "rubytube/parser"
+require_relative "rubytube/request"
+require_relative "rubytube/stream_format"
+require_relative "rubytube/stream_query"
+require_relative "rubytube/stream"
+require_relative "rubytube/utils"
 
 module RubyTube
-  class Error < StandardError; end
-  class HTMLParseError < StandardError; end
-  class ExtractError < StandardError; end
-  class MaxRetriesExceeded < StandardError; end
-  class VideoUnavailable < StandardError; end
-  class InvalidArgumentError < ArgumentError; end
-
-  class RegexMatchError < StandardError
-    def initialize(caller, pattern)
-      super("Regex match error in #{caller} for pattern #{pattern}")
-    end
-  end
-
-  class MembersOnly < StandardError
-    def initialize(video_id)
-      super("Members only video: #{video_id}")
-    end
-  end
-  
-  class RecordingUnavailable < StandardError
-    def initialize(video_id)
-      super("Recording unavailable: #{video_id}")
-    end
-  end
-  
-  class VideoUnavailable < StandardError
-    def initialize(video_id)
-      super("Video unavailable: #{video_id}")
-    end
-  end
-  
-  class VideoPrivate < StandardError
-    def initialize(video_id)
-      super("Video is private: #{video_id}")
-    end
-  end
-  
-  class LiveStreamError < StandardError
-    def initialize(video_id)
-      super("Video is a live stream: #{video_id}")
-    end
-  end
-
   class << self
     def new(url)
       Client.new(url)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubytube
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - nightswinger
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-30 00:00:00.000000000 Z
+date: 2023-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -56,6 +56,7 @@ files:
 - lib/rubytube.rb
 - lib/rubytube/cipher.rb
 - lib/rubytube/client.rb
+- lib/rubytube/error.rb
 - lib/rubytube/extractor.rb
 - lib/rubytube/innertube.rb
 - lib/rubytube/monostate.rb