yt-andrewroth 0.25.5.1

data/lib/yt/collections/user_infos.rb

@@ -0,0 +1,36 @@
+require 'yt/collections/base'
+require 'yt/models/user_info'
+
+module Yt
+  module Collections
+    # @private
+    class UserInfos < Base
+
+    private
+
+      # @return [Hash] the parameters to submit to YouTube to get the
+      #   user info of an account
+      # @see https://developers.google.com/+/api/latest/people/getOpenIdConnect
+      def list_params
+        super.tap do |params|
+          params[:path] = '/oauth2/v2/userinfo'
+          params[:expected_response] = Net::HTTPOK
+        end
+      end
+
+      # next_page is overloaded here because, differently from the other
+      # endpoints, asking for the user info does not return a paginated result,
+      # so @page_token has to be explcitly set to nil, and the result wrapped
+      # in an Array.
+      def next_page
+        request = Yt::Request.new(list_params).tap do |request|
+          print "#{request.as_curl}\n" if Yt.configuration.developing?
+        end
+        response = request.run
+        @page_token = nil
+
+        Array.wrap response.body
+      end
+    end
+  end
+end

data/lib/yt/collections/video_categories.rb

@@ -0,0 +1,35 @@
+require 'yt/collections/base'
+require 'yt/models/video_category'
+
+module Yt
+  module Collections
+    class VideoCategories < Base
+
+    private
+
+      def attributes_for_new_item(data)
+        {}.tap do |attributes|
+          attributes[:id] = data['id']
+          attributes[:snippet] = data['snippet']
+          attributes[:auth] = @auth
+        end
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to list video categories.
+      # @see https://developers.google.com/youtube/v3/docs/videoCategories/list
+      def list_params
+        super.tap do |params|
+          params[:params] = video_categories_params
+        end
+      end
+
+      def video_categories_params
+        {}.tap do |params|
+          params[:part] = 'snippet'
+          params[:id] = @parent.category_id if @parent
+          apply_where_params! params
+        end
+      end
+    end
+  end
+end

data/lib/yt/collections/videos.rb

@@ -0,0 +1,137 @@
+require 'yt/collections/base'
+require 'yt/models/video'
+
+module Yt
+  module Collections
+    # Provides methods to interact with a collection of YouTube videos.
+    #
+    # Resources with videos are: {Yt::Models::Channel channels} and
+    # {Yt::Models::Account accounts}.
+    class Videos < Base
+      def where(requirements = {})
+        @published_before = nil
+        super
+      end
+
+    private
+
+      def attributes_for_new_item(data)
+        id = use_list_endpoint? ? data['id'] : data['id']['videoId']
+        snippet = data['snippet'].reverse_merge complete: false if data['snippet']
+        {}.tap do |attributes|
+          attributes[:id] = id
+          attributes[:snippet] = snippet
+          attributes[:status] = data['status']
+          attributes[:content_details] = data['contentDetails']
+          attributes[:statistics] = data['statistics']
+          attributes[:video_category] = data['videoCategory']
+          attributes[:auth] = @auth
+        end
+      end
+
+      def eager_load_items_from(items)
+        if included_relationships.any?
+          include_category = included_relationships.delete(:category)
+          included_relationships.append(:snippet).uniq! if include_category
+
+          ids = items.map{|item| item['id']['videoId']}
+          parts = included_relationships.map{|r| r.to_s.camelize(:lower)}
+          conditions = {id: ids.join(','), part: parts.join(',')}
+          videos = Collections::Videos.new(auth: @auth).where conditions
+
+          items.each do |item|
+            video = videos.find{|v| v.id == item['id']['videoId']}
+            parts.each do |part|
+              item[part] = case part
+                when 'snippet' then video.snippet.data.merge complete: true
+                when 'status' then video.status.data
+                when 'statistics' then video.statistics_set.data
+                when 'contentDetails' then video.content_detail.data
+              end
+            end if video
+          end
+
+          if include_category
+            category_ids = items.map{|item| item['snippet']['categoryId']}.uniq
+            conditions = {id: category_ids.join(',')}
+            video_categories = Collections::VideoCategories.new(auth: @auth).where conditions
+
+            items.each do |item|
+              video_category = video_categories.find{|v| v.id == item['snippet']['categoryId']}
+              item['videoCategory'] = video_category.data
+            end
+          end
+        end
+        super
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to list videos.
+      # @see https://developers.google.com/youtube/v3/docs/search/list
+      def list_params
+        super.tap do |params|
+          params[:params] = videos_params
+          params[:path] = videos_path
+        end
+      end
+
+      def next_page
+        super.tap do |items|
+          halt_list if use_list_endpoint? && items.empty? && @page_token.nil?
+          add_offset_to(items) if !use_list_endpoint? && @page_token.nil? && videos_params[:order] == 'date'
+        end
+      end
+
+      # According to http://stackoverflow.com/a/23256768 YouTube does not
+      # provide more than 500 results for any query. In order to overcome
+      # that limit, the query is restarted with a publishedBefore filter in
+      # case there are more videos to be listed for a channel
+      def add_offset_to(items)
+        if items.count == videos_params[:max_results]
+          last_published = items.last['snippet']['publishedAt']
+          @page_token, @published_before = '', last_published
+        end
+      end
+
+      # If we ask for a list of videos matching specific IDs and no video is
+      # returned (e.g. they are all private/deleted), then we don’t want to
+      # switch from /videos to /search and keep on looking for videos, but
+      # simply return an empty array of items
+      def halt_list
+        @halt_list = true
+      end
+
+      def more_pages?
+        (@last_index.zero? && !@halt_list) || !@page_token.nil?
+      end
+
+      def videos_params
+        {}.tap do |params|
+          params[:type] = :video
+          params[:max_results] = 50
+          params[:part] = 'snippet'
+          params[:order] = 'date'
+          params.merge! @parent.videos_params if @parent
+          apply_where_params! params
+          params[:published_before] = @published_before if @published_before
+          params
+        end
+      end
+
+      def videos_path
+        use_list_endpoint? ? '/youtube/v3/videos' : '/youtube/v3/search'
+      end
+
+      # @private
+      # YouTube API provides two different endpoints to get a list of videos:
+      # /videos should be used when the query specifies video IDs or a chart,
+      # /search otherwise.
+      # @return [Boolean] whether to use the /videos endpoint.
+      # @todo: This is one of three places outside of base.rb where @where_params
+      #   is accessed; it should be replaced with a filter on params instead.
+      def use_list_endpoint?
+        @where_params ||= {}
+        @parent.nil? && (@where_params.keys & [:id, :chart]).any?
+      end
+    end
+  end
+end

data/lib/yt/config.rb

@@ -0,0 +1,54 @@
+require 'yt/models/configuration'
+
+module Yt
+  # Provides methods to read and write global configuration settings.
+  #
+  # A typical usage is to set the API keys retrieved from the
+  # {http://console.developers.google.com Google Developers Console}.
+  #
+  # @example Set the API key for a server-only YouTube app:
+  #   Yt.configure do |config|
+  #     config.api_key = 'ABCDEFGHIJ1234567890'
+  #   end
+  #
+  # @example Set the API client id/secret for a web-client YouTube app:
+  #   Yt.configure do |config|
+  #     config.client_id = 'ABCDEFGHIJ1234567890'
+  #     config.client_secret = 'ABCDEFGHIJ1234567890'
+  #   end
+  #
+  # Note that Yt.configure has precedence over values through with
+  # environment variables (see {Yt::Models::Configuration}).
+  #
+  module Config
+    # Yields the global configuration to the given block.
+    #
+    # @example
+    #   Yt.configure do |config|
+    #     config.api_key = 'ABCDEFGHIJ1234567890'
+    #   end
+    #
+    # @yield [Yt::Models::Configuration] The global configuration.
+    def configure
+      yield configuration if block_given?
+    end
+
+    # Returns the global {Yt::Models::Configuration} object.
+    #
+    # While this method _can_ be used to read and write configuration settings,
+    # it is easier to use {Yt::Config#configure} Yt.configure}.
+    #
+    # @example
+    #     Yt.configuration.api_key = 'ABCDEFGHIJ1234567890'
+    #
+    # @return [Yt::Models::Configuration] The global configuration.
+    def configuration
+      @configuration ||= Yt::Configuration.new
+    end
+  end
+
+  # @note Config is the only module auto-loaded in the Yt module,
+  #       in order to have a syntax as easy as Yt.configure
+
+  extend Config
+end

data/lib/yt/errors/forbidden.rb

@@ -0,0 +1,13 @@
+require 'yt/errors/request_error'
+
+module Yt
+  module Errors
+    class Forbidden < RequestError
+      private
+
+      def explanation
+        'A request to YouTube API was considered forbidden by the server'
+      end
+    end
+  end
+end

data/lib/yt/errors/missing_auth.rb

@@ -0,0 +1,81 @@
+require 'yt/errors/request_error'
+
+module Yt
+  module Errors
+    class MissingAuth < RequestError
+      def message
+        <<-MSG.gsub(/^ {8}/, '')
+        A request to YouTube API was sent without a valid authentication.
+
+        #{more_details}
+        MSG
+      end
+
+      def more_details
+        if scopes && authentication_url && redirect_uri
+          more_details_with_authentication_url
+        elsif scopes && user_code && verification_url
+          more_details_with_verification_url
+        else
+          more_details_without_url
+        end
+      end
+
+    private
+
+      def more_details_with_authentication_url
+        <<-MSG.gsub(/^ {8}/, '')
+        You can ask YouTube accounts to authenticate your app for the scopes
+        #{scopes} by directing them to #{authentication_url}.
+
+        After they provide access to their account, they will be redirected to
+        #{redirect_uri} with a 'code' query parameter that you can read and use
+        to build an authorized account object by running:
+
+        Yt::Account.new authorization_code: code, redirect_uri: "#{redirect_uri}"
+        MSG
+      end
+
+      def more_details_with_verification_url
+        <<-MSG.gsub(/^ {8}/, '')
+        Please authenticate your app by visiting the page #{verification_url}
+        and entering the code #{user_code} before continuing.
+        MSG
+      end
+
+      def more_details_without_url
+        <<-MSG.gsub(/^ {8}/, '')
+        If you know the access token of the YouTube you want to authenticate
+        with, build an authorized account object by running:
+
+        Yt::Account.new access_token: access_token
+
+        If you know the refresh token of the YouTube you want to authenticate
+        with, build an authorized account object by running:
+
+        Yt::Account.new refresh_token: refresh_token
+        MSG
+      end
+
+      def scopes
+        @msg[:scopes]
+      end
+
+      def authentication_url
+        @msg[:authentication_url]
+      end
+
+      def redirect_uri
+        @msg[:redirect_uri]
+      end
+
+      def user_code
+        @msg[:user_code]
+      end
+
+      def verification_url
+        @msg[:verification_url]
+      end
+    end
+  end
+end

data/lib/yt/errors/no_items.rb

@@ -0,0 +1,13 @@
+require 'yt/errors/request_error'
+
+module Yt
+  module Errors
+    class NoItems < RequestError
+      private
+
+      def explanation
+        'A request to YouTube API returned no items but some were expected'
+      end
+    end
+  end
+end

data/lib/yt/errors/request_error.rb

@@ -0,0 +1,74 @@
+require 'yt/config'
+
+module Yt
+  module Errors
+    class RequestError < StandardError
+      def initialize(msg = {})
+        @msg = msg
+        super msg
+      end
+
+      def message
+        <<-MSG.gsub(/^ {8}/, '')
+        #{explanation}:
+        #{Yt.configuration.debugging? ? details : no_details }
+        MSG
+      end
+
+      def kind
+        response_body.fetch 'error', {}
+      end
+
+      def reasons
+        case kind
+          when Hash then kind.fetch('errors', []).map{|e| e['reason']}
+          else kind
+        end
+      end
+
+    private
+
+      def explanation
+        'A request to YouTube API failed'
+      end
+
+
+      def details
+        <<-MSG.gsub(/^ {8}/, '')
+        #{response_body}
+
+        You can retry the same request manually by running:
+        #{request_curl}
+        #{more_details}
+        MSG
+      end
+
+      def no_details
+        <<-MSG.gsub(/^ {8}/, '')
+        To display more verbose errors, change the configuration of Yt with:
+
+        Yt.configure do |config|
+          config.log_level = :debug
+        end
+        MSG
+      end
+
+      def more_details
+      end
+
+      def response_body
+        json['response_body'].is_a?(Hash) ? json['response_body'] : {}
+      end
+
+      def request_curl
+        json['request_curl']
+      end
+
+      def json
+        @json ||= JSON(@msg) rescue {}
+      end
+    end
+  end
+
+  Error = Errors::RequestError
+end