yt-andrewroth 0.25.5.1

data/lib/yt/models/resource.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+
+require 'yt/models/base'
+require 'yt/models/url'
+
+module Yt
+  module Models
+    class Resource < Base
+      # @private
+      attr_reader :auth
+
+    ### ID ###
+
+      # @!attribute [r] id
+      #   @return [String] the ID that YouTube uses to identify each resource.
+      has_one :id
+
+    ### STATUS ###
+
+      has_one :status
+
+      # @!attribute [r] privacy_status
+      #   @return [String] the privacy status of the resource. Possible values
+      #     are: +'private'+, +'public'+, +'unlisted'+.
+      delegate :privacy_status, to: :status
+
+      # @return [Boolean] whether the resource is public.
+      def public?
+        privacy_status == 'public'
+      end
+
+      # @return [Boolean] whether the resource is private.
+      def private?
+        privacy_status == 'private'
+      end
+
+      # @return [Boolean] whether the resource is unlisted.
+      def unlisted?
+        privacy_status == 'unlisted'
+      end
+
+      has_one :snippet
+
+      # @private
+      def initialize(options = {})
+        @url = URL.new(options[:url]) if options[:url]
+        @id = options[:id] || (@url.id if @url)
+        @auth = options[:auth]
+        @snippet = Snippet.new(data: options[:snippet]) if options[:snippet]
+        @status = Status.new(data: options[:status]) if options[:status]
+      end
+
+      # @private
+      def kind
+        @url ? @url.kind.to_s : self.class.to_s.demodulize.underscore
+      end
+
+      # @private
+      def username
+        @url.username if @url
+      end
+
+      # @private
+      def update(attributes = {})
+        underscore_keys! attributes
+        body = build_update_body attributes
+        params = {part: body.keys.join(',')}
+        do_update params: params, body: body.merge(id: @id) do |data|
+          @id = data['id']
+          @snippet = Snippet.new data: data['snippet'] if data['snippet']
+          @status = Status.new data: data['status'] if data['status']
+          true
+        end
+      end
+
+    private
+
+      # Since YouTube API only returns tags on Videos#list, the memoized
+      # `@snippet` is erased if the video was instantiated through Video#search
+      # (e.g., by calling account.videos or channel.videos), so that the full
+      # snippet (with tags and category) is loaded, rather than the partial one.
+      def ensure_complete_snippet(attribute)
+        unless snippet.public_send(attribute).present? || snippet.complete?
+          @snippet = nil
+        end
+        snippet.public_send attribute
+      end
+
+      # TODO: instead of having Video, Playlist etc override this method,
+      #       they should define *what* can be updated in their own *update*
+      #       method.
+      # @return [Hash] the parameters to submit to YouTube to update a playlist.
+      # @see https://developers.google.com/youtube/v3/docs/playlists/update
+      # @see https://developers.google.com/youtube/v3/docs/videos/update
+      def update_params
+        super.tap do |params|
+          params[:request_format] = :json
+          params[:expected_response] = Net::HTTPOK
+        end
+      end
+
+      # @return [Hash] the parameters to submit to YouTube to delete a playlist.
+      # @see https://developers.google.com/youtube/v3/docs/playlists/delete
+      def delete_params
+        super.tap{|params| params[:params] = {id: @id}}
+      end
+
+      def build_update_body(attributes = {})
+        {}.tap do |body|
+          update_parts.each do |name, part|
+            if should_include_part_in_update? part, attributes
+              body[name] = build_update_body_part name, part, attributes
+              sanitize_brackets! body[name] if part[:sanitize_brackets]
+            end
+          end
+        end
+      end
+
+      def build_update_body_part(name, part, attributes = {})
+        {}.tap do |body_part|
+          part[:keys].map do |key|
+            body_part[camelize key] = attributes.fetch key, public_send(name).public_send(key)
+          end
+        end
+      end
+
+      def should_include_part_in_update?(part, attributes = {})
+        part[:required] || (part[:keys] & attributes.keys).any?
+      end
+
+      def camelize(value)
+        value.to_s.camelize(:lower).to_sym
+      end
+    end
+  end
+end

data/lib/yt/models/resumable_session.rb

@@ -0,0 +1,52 @@
+require 'cgi'
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # @private
+    # Provides methods to upload videos with the resumable upload protocol.
+    # @see https://developers.google.com/youtube/v3/guides/using_resumable_upload_protocol
+    class ResumableSession < Base
+      # Sets up a resumable session using the URI returned by YouTube
+      def initialize(options = {})
+        @uri = URI.parse options[:url]
+        @auth = options[:auth]
+        @headers = options[:headers]
+      end
+
+      def update(params = {})
+        do_update(params) {|data| yield data}
+      end
+
+      # Uploads a thumbnail using the current resumable session
+      # @param [#read] file A binary object that contains the image content.
+      #   Can either be a File, a StringIO (for instance using open-uri), etc.
+      # @return the new thumbnail resource for the given image.
+      # @see https://developers.google.com/youtube/v3/docs/thumbnails#resource
+      def upload_thumbnail(file)
+        do_update(body: file) {|data| data['items'].first}
+      end
+
+    private
+
+      def session_params
+        CGI::parse(@uri.query).tap{|hash| hash.each{|k,v| hash[k] = v.first}}
+      end
+
+      # @note: YouTube documentation states that a valid upload returns an HTTP
+      #   code of 201 Created -- however it looks like the actual code is 200.
+      #   To be sure to include both cases, HTTPSuccess is used
+      def update_params
+        super.tap do |params|
+          params[:request_format] = :file
+          params[:host] = @uri.host
+          params[:path] = @uri.path
+          params[:expected_response] = Net::HTTPSuccess
+          params[:headers] = @headers
+          params[:camelize_params] = false
+          params[:params] = session_params
+        end
+      end
+    end
+  end
+end

data/lib/yt/models/right_owner.rb

@@ -0,0 +1,58 @@
+require 'yt/models/description'
+
+module Yt
+  module Models
+    # Encapsulates information about the various types of owners of an asset.
+    # @see https://developers.google.com/youtube/partner/docs/v1/ownership#resource
+    class RightOwner < Base
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      # @return [Float] the percentage of the asset that the owner controls or
+      #   administers. For composition assets, the value can be any value
+      #   between 0 and 100 inclusive. For all other assets, the only valid
+      #   values are 100, which indicates that the owner completely owns the
+      #   asset in the specified territories, and 0, which indicates that you
+      #   are removing ownership of the asset in the specified territories.
+      has_attribute :ratio, type: Float
+
+      # @return [String] the name of the asset’s owner or rights administrator.
+      has_attribute :owner
+
+      # @return [String] if the asset is a composition asset and the asset
+      #   owner is not known to have a formal relationship established with
+      #   YouTube, the name of the asset’s publisher or rights administrator.
+      # @return [nil] otherwise.
+      has_attribute :publisher
+
+      # Return the list of territories where the owner owns the asset.
+      # Each territory is an ISO 3166 two-letter country code.
+      # @return [Array<String>] if the ownership lists 'included' territories,
+      #   the territories where the owner owns the asset.
+      # @return [nil] if the ownership does not list 'included' territories,
+      def included_territories
+        territories if type == 'include'
+      end
+
+      # Return the list of territories where the owner does not own the asset.
+      # Each territory is an ISO 3166 two-letter country code.
+      # @return [Array<String>] if the ownership lists 'excluded' territories,
+      #   the territories where the owner does not own the asset.
+      # @return [nil] if the ownership does not list 'excluded' territories,
+      def excluded_territories
+        territories if type == 'exclude'
+      end
+
+      # @return [Boolean] whether the ownership applies to the whole world.
+      def everywhere?
+        excluded_territories == []
+      end
+
+    private
+
+      has_attribute :type
+      has_attribute :territories, default: []
+    end
+  end
+end

data/lib/yt/models/snippet.rb

@@ -0,0 +1,50 @@
+require 'yt/models/description'
+
+module Yt
+  module Models
+    # @private
+    # Provides methods to interact with the snippet of YouTube resources.
+    # @see https://developers.google.com/youtube/v3/docs/channels#resource
+    # @see https://developers.google.com/youtube/v3/docs/videos#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlists#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlistItems#resource
+    class Snippet < Base
+      attr_reader :data
+
+      def initialize(options = {})
+        @data = options[:data]
+        @auth = options[:auth]
+      end
+
+      has_attribute :title, default: ''
+      has_attribute(:description, default: '') {|text| Description.new text}
+      has_attribute :published_at, type: Time
+      has_attribute :channel_id
+      has_attribute :channel_title
+      has_attribute :tags, default: []
+      has_attribute :category_id
+      has_attribute :live_broadcast_content
+      has_attribute :playlist_id
+      has_attribute :position, type: Integer
+      has_attribute :resource_id, default: {}
+      has_attribute :thumbnails, default: {}
+
+      def thumbnail_url(size = :default)
+        thumbnails.fetch(size.to_s, {})['url']
+      end
+
+      # Returns whether YouTube API includes all attributes in this snippet.
+      # For instance, YouTube API only returns tags and categoryId on
+      # Videos#list, not on Videos#search. And returns position on
+      # PlaylistItems#list, not on PlaylistItems#insert.
+      # This method is used to guarantee that, when a video was instantiated
+      # by one of the methods above, an additional call to is made to retrieve
+      # the full snippet in case an attribute is missing.
+      # @see https://developers.google.com/youtube/v3/docs/videos
+      # @return [Boolean] whether YouTube API includes the complete snippet.
+      def complete?
+        @complete ||= data.fetch :complete, true
+      end
+    end
+  end
+end

data/lib/yt/models/statistics_set.rb

@@ -0,0 +1,26 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # @private
+    # Encapsulates statistics about the resource, such as the number of times
+    # the resource has been viewed or liked.
+    # @see https://developers.google.com/youtube/v3/docs/videos#resource
+    class StatisticsSet < Base
+      attr_reader :data
+
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      has_attribute :view_count, type: Integer
+      has_attribute :comment_count, type: Integer
+      has_attribute :like_count, type: Integer
+      has_attribute :dislike_count, type: Integer
+      has_attribute :favorite_count, type: Integer
+      has_attribute :video_count, type: Integer
+      has_attribute :subscriber_count, type: Integer
+      has_attribute :hidden_subscriber_count
+    end
+  end
+end

data/lib/yt/models/status.rb

@@ -0,0 +1,32 @@
+require 'yt/models/timestamp'
+
+module Yt
+  module Models
+    # @private
+    # Contains information about the status of a resource. The details of the
+    # status are different for the different types of resources.
+    #
+    # Resources with a
+    # status are: channels, playlists, playlist items and videos.
+    # @see https://developers.google.com/youtube/v3/docs/channels#resource
+    # @see https://developers.google.com/youtube/v3/docs/videos#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlists#resource
+    # @see https://developers.google.com/youtube/v3/docs/playlistItems#resource
+    class Status < Base
+      attr_reader :data
+
+      def initialize(options = {})
+        @data = options[:data]
+      end
+
+      has_attribute :privacy_status
+      has_attribute :upload_status
+      has_attribute :failure_reason
+      has_attribute :rejection_reason
+      has_attribute :license
+      has_attribute :embeddable
+      has_attribute :public_stats_viewable
+      has_attribute :publish_at, type: Time
+    end
+  end
+end

data/lib/yt/models/subscription.rb

@@ -0,0 +1,38 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # @private
+    # Provides methods to interact with YouTube subscriptions.
+    # @see https://developers.google.com/youtube/v3/docs/subscriptions
+    class Subscription < Base
+      # @return [String] the ID that uniquely identify a YouTube subscription.
+      attr_reader :id
+
+      def initialize(options = {})
+        @id = options[:id]
+        @auth = options[:auth]
+      end
+
+      def delete(options = {}, &block)
+        do_delete {@id = nil}
+        !exists?
+      end
+
+      def exists?
+        !@id.nil?
+      end
+
+    private
+
+      # @return [Hash] the parameters to submit to YouTube to delete a subscription.
+      # @see https://developers.google.com/youtube/v3/docs/subscriptions/delete
+      def delete_params
+        super.tap do |params|
+          params[:path] = '/youtube/v3/subscriptions'
+          params[:params] = {id: @id}
+        end
+      end
+    end
+  end
+end

data/lib/yt/models/timestamp.rb

@@ -0,0 +1,13 @@
+module Yt
+  module Models
+    # @private
+    # Extend Time to have .to_json return the format needed to submit
+    # timestamp to YouTube API.
+    # Only needed while we support ActiveSupport 3.
+    class Timestamp < Time
+      def as_json(options = nil)
+        utc.iso8601(3)
+      end
+    end
+  end
+end

data/lib/yt/models/url.rb

@@ -0,0 +1,90 @@
+module Yt
+  module Models
+    # @private
+    class URL
+      attr_reader :kind
+
+      def initialize(url)
+        @url = url
+        @kind ||= parse url
+        @match_data ||= {}
+      end
+
+      def id
+        @match_data[:id]
+      rescue IndexError
+      end
+
+      def username
+        @match_data[:username]
+      rescue IndexError
+      end
+
+    private
+
+      def parse(url)
+        matching_pattern = patterns.find do |pattern|
+          @match_data = url.match pattern[:regex]
+        end
+        matching_pattern[:kind] if matching_pattern
+      end
+
+      def patterns
+        # @note: :channel *must* be the last since one of its regex eats the
+        # remaining patterns. In short, don't change the following order
+
+        @patterns ||= patterns_for :playlist, :subscription, :video, :channel
+      end
+
+      def patterns_for(*kinds)
+        prefix = '^(?:https?://)?(?:www\.)?'
+        suffix = '(?:|/)'
+        kinds.map do |kind|
+          patterns = send "#{kind}_patterns" # meta programming :/
+          patterns.map do |pattern|
+            {kind: kind, regex: %r{#{prefix}#{pattern}#{suffix}}}
+          end
+        end.flatten
+      end
+
+      def subscription_patterns
+        name = '(?:[a-zA-Z0-9&_=-]*)'
+
+        %W{
+          subscription_center\\?add_user=#{name}
+          subscribe_widget\\?p=#{name}
+          channel/#{name}\\?sub_confirmation=1
+        }.map{|path| "youtube\\.com/#{path}"}
+      end
+
+      def playlist_patterns
+        playlist_id = '(?<id>[a-zA-Z0-9_-]+)'
+
+        %W{
+          playlist\\?list=#{playlist_id}
+        }.map{|path| "youtube\\.com/#{path}"}
+      end
+
+      def video_patterns
+        video_id = '(?<id>[a-zA-Z0-9_-]+)'
+
+        %W{
+          youtube\\.com/watch\\?v=#{video_id}
+          youtu\\.be/#{video_id}
+          youtube\\.com/embed/#{video_id}
+        }
+      end
+
+      def channel_patterns
+        channel_id = '(?<id>[a-zA-Z0-9_-]+)'
+        username = '(?<username>[a-zA-Z0-9_-]+)'
+
+        %W{
+          channel/#{channel_id}
+          user/#{username}
+          #{username}
+        }.map{|path| "youtube\\.com/#{path}"}
+      end
+    end
+  end
+end