yt-andrewroth 0.25.5.1

data/lib/yt/errors/server_error.rb

@@ -0,0 +1,13 @@
+require 'yt/errors/request_error'
+
+module Yt
+  module Errors
+    class ServerError < RequestError
+      private
+
+      def explanation
+        'A request to YouTube API caused an unexpected server error'
+      end
+    end
+  end
+end

data/lib/yt/errors/unauthorized.rb

@@ -0,0 +1,50 @@
+require 'yt/errors/request_error'
+require 'yt/config'
+
+module Yt
+  module Errors
+    class Unauthorized < RequestError
+      private
+
+      def explanation
+        'A request to YouTube API was sent without a valid authentication'
+      end
+
+      def more_details
+        if [Yt.configuration.client_id, Yt.configuration.api_key].none?
+          <<-MSG.gsub(/^ {10}/, '')
+          In order to perform this request, you need to register your app with
+          Google Developers Console (https://console.developers.google.com).
+
+          Make sure your app has access to the Google+ and YouTube APIs.
+
+          If your app requires read-only access to public YouTube data, then
+          generate a server API key and set its value with the initializer:
+
+          Yt.configure do |config|
+            config.api_key = '123456789012345678901234567890'
+          end
+
+          or through an environment variable:
+
+          export YT_API_KEY="123456789012345678901234567890"
+
+          If your app needs to perform actions on behalf of YouTube accounts,
+          then generate a client ID and SECRET and set their values with the
+          initializer:
+
+          Yt.configure do |config|
+            config.client_id = '1234567890.apps.googleusercontent.com'
+            config.client_secret = '1234567890'
+          end
+
+          or through environment variables:
+
+          export YT_CLIENT_ID="1234567890.apps.googleusercontent.com"
+          export YT_CLIENT_SECRET="1234567890"
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/yt/models/account.rb

@@ -0,0 +1,216 @@
+require 'open-uri'
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube accounts.
+    # @see https://developers.google.com/youtube/v3/guides/authentication
+    class Account < Base
+
+    ### USER INFO ###
+
+      has_one :user_info
+
+      # @!attribute [r] id
+      #   @return [String] the (Google+) account’s ID.
+      delegate :id, to: :user_info
+
+      # @!attribute [r] email
+      #   @return [String] the account’s email address.
+      delegate :email, to: :user_info
+
+      # @return [Boolean] whether the email address is verified.
+      def has_verified_email?
+        user_info.verified_email
+      end
+
+      # @!attribute [r] name
+      #   @return [String] the account’s full name.
+      delegate :name, to: :user_info
+
+      # @!attribute [r] given_name
+      #   @return [String] the user’s given (first) name.
+      delegate :given_name, to: :user_info
+
+      # @!attribute [r] family_name
+      #   @return [String] the user’s family (last) name.
+      delegate :family_name, to: :user_info
+
+      # @return [String] the URL of the account’s (Google +) profile page.
+      def profile_url
+        user_info.link
+      end
+
+      # @return [String] the URL of the account’s (Google +) profile picture.
+      def avatar_url
+        user_info.picture
+      end
+
+      # @return [String] the account’s gender. Possible values include, but
+      #   are not limited to, +'male'+, +'female'+, +'other'+.
+      delegate :gender, to: :user_info
+
+      # @return [String] the account’s preferred locale.
+      delegate :locale, to: :user_info
+
+      # @return [String] the hosted domain name for the user’s Google Apps
+      #   account. For instance, example.com.
+      delegate :hd, to: :user_info
+
+    ### ACTIONS ###
+
+      # Uploads a video to the account’s channel.
+      # @param [String] path_or_url the video to upload. Can either be the
+      #   path of a local file or the URL of a remote file.
+      # @param [Hash] params the metadata to add to the uploaded video.
+      # @option params [String] :title The video’s title.
+      # @option params [String] :description The video’s description.
+      # @option params [Array<String>] :title The video’s tags.
+      # @option params [String] :privacy_status The video’s privacy status.
+      # @return [Yt::Models::Video] the newly uploaded video.
+      def upload_video(path_or_url, params = {})
+        file = open path_or_url, 'rb'
+        session = resumable_sessions.insert file.size, upload_body(params)
+
+        session.update(body: file) do |data|
+          Yt::Video.new id: data['id'], snippet: data['snippet'], status: data['privacyStatus'], auth: self
+        end
+      end
+
+      # Creates a playlist in the account’s channel.
+      # @return [Yt::Models::Playlist] the newly created playlist.
+      # @param [Hash] params the attributes of the playlist.
+      # @option params [String] :title The new playlist’s title.
+      #   Cannot have more than 100 characters. Can include the characters
+      #   < and >, which are replaced to ‹ › in order to be accepted by YouTube.
+      # @option params [String] :description The new playlist’s description.
+      #   Cannot have more than 5000 bytes. Can include the characters
+      #   < and >, which are replaced to ‹ › in order to be accepted by YouTube.
+      # @option params [Array<String>] :tags The new playlist’s tags.
+      #   Cannot have more than 500 characters. Can include the characters
+      #   < and >, which are replaced to ‹ › in order to be accepted by YouTube.
+      # @option params [String] :privacy_status The new playlist’s privacy
+      #   status. Must be one of: private, unscheduled, public.
+      # @example Create a playlist titled "My favorites".
+      #   account.create_playlist title: 'My favorites'
+      def create_playlist(params = {})
+        playlists.insert params
+      end
+
+      # @!method delete_playlists(attributes = {})
+      #   Deletes the account’s playlists matching all the given attributes.
+      #   @return [Array<Boolean>] whether each playlist matching the given
+      #     attributes was deleted.
+      #   @param [Hash] attributes the attributes to match the playlists by.
+      #   @option attributes [<String, Regexp>] :title The playlist’s title.
+      #     Pass a String for perfect match or a Regexp for advanced match.
+      #   @option attributes [<String, Regexp>] :description The playlist’s
+      #     description. Pass a String (perfect match) or a Regexp (advanced).
+      #   @option attributes [Array<String>] :tags The playlist’s tags.
+      #     All tags must match exactly.
+      #   @option attributes [String] :privacy_status The playlist’s privacy
+      #     status.
+      delegate :delete_playlists, to: :channel
+
+    ### CONTENT OWNERS ###
+
+      # @!attribute [r] content_owners
+      #   @return [Yt::Collections::ContentOwners] the content owners that
+      #     the account can manage.
+      has_many :content_owners
+
+      # The name of the content owner managing the account.
+      # @return [String] name of the CMS account, if the account is partnered.
+      # @return [nil] if the account is not a partnered content owner.
+      attr_reader :owner_name
+
+    ### ASSOCIATIONS ###
+
+      # @!attribute [r] channel
+      #   @return [Yt::Models::Channel] the YouTube channel of the account.
+      has_one :channel
+
+      # @!attribute [r] playlists
+      #   @return [Yt::Collections::Playlists] the playlists owned by the account.
+      delegate :playlists, to: :channel
+
+      # @!attribute [r] related_playlists
+      #   @return [Yt::Collections::Playlists] the playlists associated with the
+      #     account, such as the playlist of uploaded or liked videos.
+      #   @see https://developers.google.com/youtube/v3/docs/channels#contentDetails.relatedPlaylists
+      delegate :related_playlists, to: :channel
+
+      # @!attribute [r] subscribed_channels
+      #   @return [Yt::Collections::SubscribedChannels] the channels that the
+      #     account is subscribed to.
+      delegate :subscribed_channels, to: :channel
+
+      # @!attribute [r] videos
+      #   @return [Yt::Collections::Videos] the videos owned by the account.
+      has_many :videos
+
+      # @!attribute [r] subscribers
+      #   @return [Yt::Collections::Subscribers] the channels subscribed to
+      #     the account’s channel.
+      has_many :subscribers
+
+      # @!attribute [r] resumable_sessions
+      #   @private
+      #   @return [Yt::Collections::ResumableSessions] the sessions used to
+      #     upload videos using the resumable upload protocol.
+      has_many :resumable_sessions
+
+    ### PRIVATE API ###
+
+      has_authentication
+
+      # @private
+      # Initialize user info if included in the response
+      def initialize(options = {})
+        super options
+        if options[:user_info]
+          @user_info = UserInfo.new data: options[:user_info]
+        end
+      end
+
+      # @private
+      # Tells `has_many :videos` that account.videos should return all the
+      # videos *owned by* the account (public, private, unlisted).
+      def videos_params
+        {for_mine: true}
+      end
+
+      # @private
+      # Tells `has_many :resumable_sessions` what path to hit to upload a file.
+      def upload_path
+        '/upload/youtube/v3/videos'
+      end
+      # @private
+      # Tells `has_many :resumable_sessions` what params are set for the object
+      # associated to the uploaded file.
+      def upload_params
+        {part: 'snippet,status'}
+      end
+
+      # @private
+      # Tells `has_many :resumable_sessions` what metadata to set in the object
+      # associated to the uploaded file.
+      def upload_body(params = {})
+        {}.tap do |body|
+          snippet = params.slice :title, :description, :tags, :category_id
+          snippet[:categoryId] = snippet.delete(:category_id) if snippet[:category_id]
+          body[:snippet] = snippet if snippet.any?
+
+          status = params[:privacy_status]
+          body[:status] = {privacyStatus: status} if status
+        end
+      end
+
+      # @private
+      # Tells `has_many :resumable_sessions` what type of file can be uploaded.
+      def upload_content_type
+        'video/*'
+      end
+    end
+  end
+end

data/lib/yt/models/advertising_options_set.rb

@@ -0,0 +1,38 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # Encapsulates advertising options of a video, such as the types of ads
+    # that can run during the video as well as the times when ads are allowed
+    # to run during the video.
+    # @see https://developers.google.com/youtube/partner/docs/v1/videoAdvertisingOptions#resource
+    class AdvertisingOptionsSet < Base
+      def initialize(options = {})
+        @auth = options[:auth]
+        @video_id = options[:video_id]
+        @data = options[:data]
+      end
+
+      def update(attributes = {})
+        underscore_keys! attributes
+        do_patch(body: attributes) {|data| @data = data}
+        true
+      end
+
+      def ad_formats
+        @data['adFormats']
+      end
+
+    private
+
+      # @see https://developers.google.com/youtube/partner/docs/v1/videoAdvertisingOptions/patch
+      def patch_params
+        super.tap do |params|
+          params[:expected_response] = Net::HTTPOK
+          params[:path] = "/youtube/partner/v1/videoAdvertisingOptions/#{@video_id}"
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
+        end
+      end
+    end
+  end
+end

data/lib/yt/models/annotation.rb

@@ -0,0 +1,132 @@
+module Yt
+  module Models
+    # Provides methods to interact with YouTube annotations.
+    # @note YouTube API V3 does not provide access to video annotations,
+    #   therefore a legacy XML endpoint is used to retrieve annotations.
+    # @see https://www.youtube.com/yt/playbook/annotations.html
+    class Annotation < Base
+      # @param [Hash] options the options to initialize an Annotation.
+      # @option options [String] :data The XML representation of an annotation
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      # @return [Boolean] whether the text box surrounding the annotation is
+      #   completely in the top y% of the video frame.
+      # @param [Integer] y Vertical position in the Youtube video (0 to 100)
+      def above?(y)
+        top && top < y
+      end
+
+      # @return [Boolean] whether the text box surrounding the annotation is
+      #   completely in the bottom y% of the video frame.
+      # @param [Integer] y Vertical position in the Youtube video (0 to 100)
+      def below?(y)
+        bottom && bottom > y
+      end
+
+      # @return [Boolean] whether the annotation includes a link to subscribe.
+      def has_link_to_subscribe?(options = {}) # TODO: options for which videos
+        link_class == '5'
+      end
+
+      # @return [Boolean] whether the annotation includes a link to a video,
+      #   either directly in the text, or as an "Invideo featured video".
+      def has_link_to_video?(options = {}) # TODO: options for which videos
+        link_class == '1' || type == 'promotion'
+      end
+
+      # @return [Boolean] whether the annotation includes a link to a playlist,
+      #   or to a video embedded in a playlist.
+      def has_link_to_playlist?
+        link_class == '2' || text.include?('&list=')
+      end
+
+      # @return [Boolean] whether the annotation includes a link that will
+      #   open in the current browser window.
+      def has_link_to_same_window?
+        link_target == 'current'
+      end
+
+      # @return [Boolean] whether the annotation is an "InVideo Programming".
+      def has_invideo_programming?
+        type == 'promotion' || type == 'branding'
+      end
+
+      # @param [Numeric] seconds the number of seconds
+      # @return [Boolean] whether the annotation starts after the number of
+      #   seconds indicated.
+      # @note This is broken for invideo programming, because they do not
+      #   have the timestamp in the region, but in the "data" field
+      def starts_after?(seconds)
+        timestamps.first > seconds if timestamps.any?
+      end
+
+      # @param [Numeric] seconds the number of seconds
+      # @return [Boolean] whether the annotation starts before the number of
+      #   seconds indicated.
+      # @note This is broken for invideo programming, because they do not
+      #   have the timestamp in the region, but in the "data" field
+      def starts_before?(seconds)
+        timestamps.first < seconds if timestamps.any?
+      end
+
+      # @return [String] the textual content of the annotation.
+      def text
+        @text ||= @data['TEXT'] || ''
+      end
+
+    private
+
+      has_attribute :type, default: ''
+
+      def link_class
+        @link_class ||= url['link_class']
+      end
+
+      def link_target
+        @link_target ||= url['target']
+      end
+
+      def url
+        @url ||= action.fetch 'url', {}
+      end
+
+      has_attribute :action, default: {}
+
+      def top
+        @top ||= positions.map{|pos| pos['y'].to_f}.max
+      end
+
+      def bottom
+        @bottom ||= positions.map{|pos| pos['y'].to_f + pos['h'].to_f}.max
+      end
+
+      def timestamps
+        @timestamps ||= positions.reject{|pos| pos['t'] == 'never'}.map do |pos|
+          timestamp_of pos
+        end
+      end
+
+      def timestamp_of(position)
+        regex = %r{(?:|(?<hours>\d*):)(?:|(?<min>\d*):)(?<sec>\d*)\.(?<ms>\d*)}
+        position['t'] = '00:00:00.000' if position['t'] == '0'
+        match = position['t'].match regex
+        hours = (match[:hours] || '0').to_i
+        minutes = (match[:min] || '0').to_i
+        seconds = (match[:sec]).to_i
+        (hours * 60 + minutes) * 60 + seconds
+      end
+
+      def positions
+        @positions ||= Array.wrap region['rectRegion'] || region['anchoredRegion']
+      end
+
+      def region
+        @region ||= segment.fetch 'movingRegion', {}
+      end
+
+      has_attribute :segment, type: Hash
+    end
+  end
+end