rubytube 0.3.0 → 0.5.0

data/lib/rubytube/parser.rb

@@ -1,164 +1,159 @@
-module RubyTube
-  module Parser
-    module_function
-
-    def parse_for_object(html, preceding_regex)
-      regex = Regexp.new(preceding_regex)
-      result = regex.match(html)
-
-      if result.nil?
-        raise HTMLParseError, "No matches for regex #{preceding_regex}"
-      end
-      start_index = result.end(0)
-
-      return 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])
-        raise HTMLParseError, "Invalid start point. Start of HTML:\n#{html[0..19]}"
-      end
-
-      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)
-        curr_char = html[i]
-        curr_context = stack.last
-
-        if curr_char == context_closers[curr_context]
-          stack.pop
-          i += 1
-          next
-        end
-
-        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
-          end
-        end
-
-        i += 1
-      end
-
-      full_obj = html[0...i]
-      full_obj
-    end
-
-    def parse_for_object_from_startpoint(html, start_point)
-      html = html[start_point..-1]
-
-      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 = '{'
-      curr_char = nil
-      stack = [html[0]]
-      i = 1
-
-      context_closers = {
-        '{' => '}',
-        '[' => ']',
-        '"' => '"',
-        '/' => '/' # JavaScript regex
-      }
-
-      while i < html.length
-        break if stack.empty?
-    
-        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
-          i += 1
-          next
-        end
-        # Strings and regex expressions require special context handling because they can contain
-        # context openers *and* closers
-        if ['"', '/'].include?(curr_context)
-          # If there's a backslash in a string or regex expression, we skip a character
-          if curr_char == '\\'
-            i += 2
-            next
-          end
-        else
-          # 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
-          end
-        end
-
-        i += 1
-      end
-
-      full_obj = html[0..(i - 1)]
-      full_obj
-    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')
-          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
-          curr_substring = curr_substring[full_function_def.length + 1..-1]
-        else
-          match = comma_regex.match(curr_substring)
-
-          begin
-            match_start = match.begin(0)
-            match_end = match.end(0)
-          rescue NoMethodError
-            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
-end
+module RubyTube
+  module Parser
+    module_function
+
+    def parse_for_object(html, preceding_regex)
+      regex = Regexp.new(preceding_regex)
+      result = regex.match(html)
+
+      if result.nil?
+        raise HTMLParseError, "No matches for regex #{preceding_regex}"
+      end
+      start_index = result.end(0)
+
+      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])
+        raise HTMLParseError, "Invalid start point. Start of HTML:\n#{html[0..19]}"
+      end
+
+      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)
+        curr_char = html[i]
+        curr_context = stack.last
+
+        if curr_char == context_closers[curr_context]
+          stack.pop
+          i += 1
+          next
+        end
+
+        if ['"', "/"].include?(curr_context)
+          if curr_char == "\\"
+            i += 2
+            next
+          end
+        elsif context_closers.keys.include?(curr_char)
+          unless curr_char == "/" && !["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";"].include?(last_char)
+            stack.push(curr_char)
+          end
+        end
+
+        i += 1
+      end
+
+      html[0...i]
+    end
+
+    def parse_for_object_from_startpoint(html, start_point)
+      html = html[start_point..-1]
+
+      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 = "{"
+      curr_char = nil
+      stack = [html[0]]
+      i = 1
+
+      context_closers = {
+        "{" => "}",
+        "[" => "]",
+        '"' => '"',
+        :"'" => "'",
+        "/" => "/" # JavaScript regex
+      }
+
+      while i < html.length
+        break if stack.empty?
+
+        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
+          i += 1
+          next
+        end
+        # Strings and regex expressions require special context handling because they can contain
+        # context openers *and* closers
+        if ['"', "/"].include?(curr_context)
+          # If there's a backslash in a string or regex expression, we skip a character
+          if curr_char == "\\"
+            i += 2
+            next
+          end
+        elsif context_closers.keys.include?(curr_char)
+          # Non-string contexts are when we need to look for context openers.
+          unless curr_char == "/" && ["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";"].include?(last_char)
+            stack << curr_char
+          end
+          # Slash starts a regular expression depending on context
+        end
+
+        i += 1
+      end
+
+      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")
+          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
+          curr_substring = curr_substring[full_function_def.length + 1..-1]
+        else
+          match = comma_regex.match(curr_substring)
+
+          begin
+            match_start = match.begin(0)
+            match_end = match.end(0)
+          rescue NoMethodError
+            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
+end

data/lib/rubytube/request.rb

@@ -1,75 +1,73 @@
-module RubyTube
-  module Request
-    module_function
-
-    DEFAULT_RANGE_SIZE = 9437184
-
-    def get(url, options = {})
-      send(:get, url, options).body
-    end
-
-    def post(url, options = {})
-      send(:post, url, options).body
-    end
-
-    def head(url, options = {})
-      send(:head, url, options).headers
-    end
-
-    def stream(url, timeout: 60, max_retries: 0)
-      file_size = DEFAULT_RANGE_SIZE
-      downloaded = 0
-
-      while downloaded < file_size
-        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
-              raise MaxRetriesExceeded
-            end
-            response = send(:get, "#{url}&range=#{downloaded}-#{stop_pos}")
-            break
-          rescue Faraday::TimeoutError
-          rescue Faraday::ClientError => e
-            raise e
-          end
-          tries += 1
-        end
-
-        if file_size == DEFAULT_RANGE_SIZE
-          begin
-            resp = send(:get, "#{url}&range=0-99999999999")
-            content_range = resp.headers["Content-Length"]
-            file_size = content_range.to_i
-          rescue KeyError, IndexError, StandardError => e
-          end
-        end
-
-        response.body.each_char do |chunk|
-          downloaded += chunk.length
-          yield chunk
-        end
-      end
-    end
-
-    def send(method, url, options = {})
-      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|
-        req.headers = headers
-        options[:query] && req.params = options[:query] 
-        options[:data] && req.body = JSON.dump(options[:data])
-      end
-
-      response
-    end
-  end
-end
+module RubyTube
+  module Request
+    module_function
+
+    DEFAULT_RANGE_SIZE = 9437184
+
+    def get(url, options = {})
+      send(:get, url, options).body
+    end
+
+    def post(url, options = {})
+      send(:post, url, options).body
+    end
+
+    def head(url, options = {})
+      send(:head, url, options).headers
+    end
+
+    def stream(url, timeout: 60, max_retries: 0)
+      file_size = DEFAULT_RANGE_SIZE
+      downloaded = 0
+
+      while downloaded < file_size
+        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
+              raise MaxRetriesExceeded
+            end
+            response = send(:get, "#{url}&range=#{downloaded}-#{stop_pos}")
+            break
+          rescue Faraday::TimeoutError
+          rescue Faraday::ClientError => e
+            raise e
+          end
+          tries += 1
+        end
+
+        if file_size == DEFAULT_RANGE_SIZE
+          begin
+            resp = send(:get, "#{url}&range=0-99999999999")
+            content_range = resp.headers["Content-Length"]
+            file_size = content_range.to_i
+          rescue KeyError, IndexError, StandardError => e
+          end
+        end
+
+        response.body.each_char do |chunk|
+          downloaded += chunk.length
+          yield chunk
+        end
+      end
+    end
+
+    def send(method, url, options = {})
+      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
+      connection.send(method) do |req|
+        req.headers = headers
+        options[:query] && req.params = options[:query]
+        options[:data] && req.body = JSON.dump(options[:data])
+      end
+    end
+  end
+end

data/lib/rubytube/stream.rb

@@ -1,97 +1,95 @@
-module RubyTube
-  class Stream
-    attr_accessor(
-      :monostate,
-      :url,
-      :itag,
-      :mime_type,
-      :codecs,
-      :type,
-      :subtype,
-      :file_size,
-      :is_otf,
-      :bitrate
-    )
-
-    def initialize(stream, monostate)
-      self.monostate = monostate
-
-      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.is_otf = stream['is_otf']
-      self.bitrate = stream['bitrate']
-
-      self.file_size = stream.fetch('contentLength', 0).to_i
-    end
-
-    def download(filename: nil, output_dir: nil)
-      file_path = get_file_path(filename, output_dir)
-
-      return file_path if File.exist?(file_path)
-
-      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
-        end
-      end
-
-      file_path
-    end
-
-    def is_audio?
-      type == 'audio'
-    end
-
-    def is_video?
-      type == 'video'
-    end
-
-    def is_adaptive?
-      codecs.size % 2 == 1
-    end
-
-    def is_progressive?
-      !is_adaptive?
-    end
-
-    def title
-      monostate.title
-    end
-
-    def resolution
-      stream_format.resolution
-    end
-
-    private
-
-    def get_file_path(filename, output_dir, prefix = '')
-      filename = default_filename unless filename
-
-      if prefix
-        filename = "#{prefix}#{filename}"
-      end
-
-      output_path = Utils.target_directory(output_dir)
-      File.join(output_path, filename)
-    end
-
-    def default_filename
-      "#{monostate.title}.#{subtype}"
-    end
-
-    def stream_format
-      @stream_format ||= StreamFormat.new(itag)
-    end
-  end
-end
+module RubyTube
+  class Stream
+    attr_accessor(
+      :monostate,
+      :url,
+      :itag,
+      :mime_type,
+      :codecs,
+      :type,
+      :subtype,
+      :file_size,
+      :is_otf,
+      :bitrate
+    )
+
+    def initialize(stream, monostate)
+      self.monostate = monostate
+
+      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.is_otf = stream["is_otf"]
+      self.bitrate = stream["bitrate"]
+
+      self.file_size = stream.fetch("contentLength", 0).to_i
+    end
+
+    def download(filename: nil, output_dir: nil)
+      file_path = get_file_path(filename, output_dir)
+
+      return file_path if File.exist?(file_path)
+
+      bytes_remaining = file_size
+
+      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"
+    end
+
+    def is_video?
+      type == "video"
+    end
+
+    def is_adaptive?
+      codecs.size % 2 == 1
+    end
+
+    def is_progressive?
+      !is_adaptive?
+    end
+
+    def title
+      monostate.title
+    end
+
+    def resolution
+      stream_format.resolution
+    end
+
+    private
+
+    def get_file_path(filename, output_dir, prefix = "")
+      filename ||= default_filename
+
+      if prefix
+        filename = "#{prefix}#{filename}"
+      end
+
+      output_path = Utils.target_directory(output_dir)
+      File.join(output_path, filename)
+    end
+
+    def default_filename
+      "#{monostate.title}.#{subtype}"
+    end
+
+    def stream_format
+      @stream_format ||= StreamFormat.new(itag)
+    end
+  end
+end