yt 0.11.1 → 0.11.2

data/lib/yt/collections/references.rb

@@ -9,8 +9,8 @@ module Yt
     class References < Base
       def insert(attributes = {})
         underscore_keys! attributes
-        body = {contentType: attributes[:content_type] }
-        params = {claimId: attributes[:claim_id], onBehalfOfContentOwner: @auth.owner_name}
+        body = {content_type: attributes[:content_type] }
+        params = {claim_id: attributes[:claim_id], on_behalf_of_content_owner: @auth.owner_name}
         do_insert(params: params, body: body)
       end
 
@@ -41,16 +41,6 @@ module Yt
       def references_params
         apply_where_params! on_behalf_of_content_owner: @parent.owner_name
       end
-
-      # If we dropped support for ActiveSupport 3, then we could simply
-      # invoke transform_keys!{|key| key.to_s.underscore.to_sym}
-      def underscore_keys!(hash)
-        hash.dup.each_key{|key| hash[underscore key] = hash.delete key}
-      end
-
-      def underscore(value)
-        value.to_s.underscore.to_sym
-      end
     end
   end
 end

data/lib/yt/collections/resources.rb

@@ -59,12 +59,6 @@ module Yt
         (part[:keys] & attributes.keys).any?
       end
 
-      # If we dropped support for ActiveSupport 3, then we could simply
-      # invoke transform_keys!{|key| key.to_s.underscore.to_sym}
-      def underscore_keys!(hash)
-        hash.dup.each_key{|key| hash[underscore key] = hash.delete key}
-      end
-
       # @return [Hash] the original hash with angle brackets characters in its
       #   values replaced with similar Unicode characters accepted by Youtube.
       # @see https://support.google.com/youtube/answer/57404?hl=en
@@ -79,10 +73,6 @@ module Yt
       def camelize(value)
         value.to_s.camelize(:lower).to_sym
       end
-
-      def underscore(value)
-        value.to_s.underscore.to_sym
-      end
     end
   end
 end

data/lib/yt/models/account.rb

@@ -56,7 +56,7 @@ module Yt
       # Tells `has_many :videos` that account.videos should return all the
       # videos *owned by* the account (public, private, unlisted).
       def videos_params
-        {forMine: true}
+        {for_mine: true}
       end
     end
   end

data/lib/yt/models/advertising_options_set.rb

@@ -0,0 +1,33 @@
+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]
+      end
+
+      def update(attributes = {})
+        underscore_keys! attributes
+        do_patch body: attributes
+        true
+      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/asset.rb

@@ -0,0 +1,100 @@
+require 'yt/models/base'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube ContentID assets.
+    # @see https://developers.google.com/youtube/partner/docs/v1/assets
+    class Asset < Base
+      attr_reader :auth
+
+      def initialize(options = {})
+        @data = options[:data]
+        @id = options[:id]
+        @auth = options[:auth]
+      end
+
+      # @!attribute [r] ownership
+      #   @return [Yt::Models::Ownership] the asset’s ownership.
+      has_one :ownership
+      delegate :general_owners, :performance_owners, :synchronization_owners,
+        :mechanical_owners, to: :ownership
+
+      # Soft-deletes the asset.
+      # @note YouTube API does not provide a +delete+ method for the Asset
+      #   resource, but only an +update+ method. Updating the +status+ of a
+      #   Asset to "inactive" can be considered a soft-deletion.
+      # @note Despite what the documentation says, YouTube API never returns
+      #   the status of an asset, so it’s impossible to update, although the
+      #   documentation says this should be the case. If YouTube ever fixes
+      #   the API, then the following code can be uncommented.
+      # @return [Boolean] whether the asset is inactive.
+      # def delete
+      #   body = {id: id, status: :inactive}
+      #   do_update(body: body) {|data| @data = data}
+      #   inactive?
+      # end
+
+      # @return [String] the ID that YouTube assigns and uses to uniquely
+      #   identify the asset.
+      def id
+        @id ||= @data['id']
+      end
+
+      # @return [String] the asset’s type. This value determines the metadata
+      #   fields that you can set for the asset. In addition, certain API
+      #   functions may only be supported for specific types of assets. For
+      #   example, composition assets may have more complex ownership data than
+      #   other types of assets.
+      #   Valid values for this property are: art_track_video, composition,
+      #   episode, general, movie, music_video, season, show, sound_recording,
+      #   video_game, and web.
+      def type
+        @type ||= @data['type']
+      end
+
+# Status
+
+      STATUSES = %q(active inactive pending)
+
+      # @return [String] the asset’s status. Valid values are: active,
+      #   inactive, and pending.
+      # @note Despite what the documentation says, YouTube API never returns
+      #   the status of an asset, so it’s impossible to update, although the
+      #   documentation says this should be the case. If YouTube ever fixes
+      #   the API, then the following code can be uncommented.
+      # def status
+      #   @status ||= @data["status"]
+      # end
+      #
+      # # @return [Boolean] whether the asset is active.
+      # def active?
+      #   status == 'active'
+      # end
+      #
+      # # @return [Boolean] whether the asset is inactive.
+      # def inactive?
+      #   status == 'inactive'
+      # end
+      #
+      # # @return [Boolean] whether the asset is pending.
+      # def pending?
+      #   status == 'pending'
+      # end
+
+    private
+
+      # @see https://developers.google.com/youtube/partner/docs/v1/assets/update
+      # @note Despite what the documentation says, YouTube API never returns
+      #   the status of an asset, so it’s impossible to update, although the
+      #   documentation says this should be the case. If YouTube ever fixes
+      #   the API, then the following code can be uncommented.
+      # def update_params
+      #   super.tap do |params|
+      #     params[:expected_response] = Net::HTTPOK
+      #     params[:path] = "/youtube/partner/v1/assets/#{id}"
+      #     params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
+      #   end
+      # end
+    end
+  end
+end

data/lib/yt/models/channel.rb

@@ -124,7 +124,7 @@ module Yt
       # Tells `has_many :videos` that channel.videos should return all the
       # videos publicly available on the channel.
       def videos_params
-        {channelId: id}
+        {channel_id: id}
       end
 
       # @private

data/lib/yt/models/claim.rb

@@ -7,6 +7,19 @@ module Yt
     class Claim < Base
       def initialize(options = {})
         @data = options[:data]
+        @id = options[:id]
+        @auth = options[:auth]
+      end
+
+      # Soft-deletes the claim.
+      # @note YouTube API does not provide a +delete+ method for the Asset
+      #   resource, but only an +update+ method. Updating the +status+ of a
+      #   Asset to "inactive" can be considered a soft-deletion.
+      # @return [Boolean] whether the claim is inactive.
+      def delete
+        body = {status: :inactive}
+        do_patch(body: body) {|data| @data = data}
+        inactive?
       end
 
       # @return [String] the ID that YouTube assigns and uses to uniquely
@@ -137,6 +150,15 @@ module Yt
       def match_reference_id
         @match_reference_id ||= @data.fetch('matchInfo', {})['referenceId']
       end
+
+      # @see https://developers.google.com/youtube/partner/docs/v1/claims/update
+      def patch_params
+        super.tap do |params|
+          params[:expected_response] = Net::HTTPOK
+          params[:path] = "/youtube/partner/v1/claims/#{id}"
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
+        end
+      end
     end
   end
 end

data/lib/yt/models/content_owner.rb

@@ -8,19 +8,23 @@ module Yt
     class ContentOwner < Account
 
       # @!attribute [r] partnered_channels
-      #   @return [Yt::Collection::PartneredChannels] the channels managed by the CMS account.
+      #   @return [Yt::Collections::PartneredChannels] the channels managed by the CMS account.
       has_many :partnered_channels
 
       # @!attribute [r] claims
-      #   @return [Yt::Collection::Claims] the claims administered by the content owner.
+      #   @return [Yt::Collections::Claims] the claims administered by the content owner.
       has_many :claims
 
+      # @!attribute [r] assets
+      #   @return [Yt::Collection::Assets] the assets administered by the content owner.
+      has_many :assets
+
       # @!attribute [r] references
-      #   @return [Yt::Collection::References] the references administered by the content owner.
+      #   @return [Yt::Collections::References] the references administered by the content owner.
       has_many :references
 
       # @!attribute [r] policies
-      #   @return [Yt::Collection::Policies] the policies saved by the content owner.
+      #   @return [Yt::Collections::Policies] the policies saved by the content owner.
       has_many :policies
 
       def initialize(options = {})
@@ -31,6 +35,14 @@ module Yt
       def create_reference(params = {})
         references.insert params
       end
+
+      def create_asset(params = {})
+        assets.insert params
+      end
+
+      def create_claim(params = {})
+        claims.insert params
+      end
     end
   end
 end

data/lib/yt/models/match_policy.rb

@@ -13,7 +13,7 @@ module Yt
 
       def update(attributes = {})
         underscore_keys! attributes
-        do_patch body: {policyId: attributes[:policy_id]}
+        do_patch body: attributes.slice(:policy_id)
         true
       end
 
@@ -25,20 +25,10 @@ module Yt
       def patch_params
         super.tap do |params|
           params[:path] = "/youtube/partner/v1/assets/#{@asset_id}/matchPolicy"
-          params[:params] = {onBehalfOfContentOwner: @auth.owner_name}
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
           params[:expected_response] = Net::HTTPOK
         end
       end
-
-      # If we dropped support for ActiveSupport 3, then we could simply
-      # invoke transform_keys!{|key| key.to_s.underscore.to_sym}
-      def underscore_keys!(hash)
-        hash.dup.each_key{|key| hash[underscore key] = hash.delete key}
-      end
-
-      def underscore(value)
-        value.to_s.underscore.to_sym
-      end
     end
   end
 end

data/lib/yt/models/ownership.rb

@@ -0,0 +1,70 @@
+require 'yt/models/base'
+require 'yt/models/right_owner'
+
+module Yt
+  module Models
+    # Provides methods to interact with YouTube ContentID asset ownership,
+    # which provide ownership information for the specified asset.
+    # @see https://developers.google.com/youtube/partner/docs/v1/ownership
+    class Ownership < Base
+      def initialize(options = {})
+        @data = options[:data] || {}
+        @auth = options[:auth]
+        @asset_id = options[:asset_id]
+      end
+
+      def update(attributes = {})
+        underscore_keys! attributes
+        do_update body: attributes
+        true
+      end
+
+      # Assigns 100% of the general ownership of the asset to @auth.
+      def obtain!
+        update general: [{ratio: 100, owner: @auth.owner_name, type: :exclude}]
+      end
+
+      # @return [Array<RightOwner>] a list that identifies the owners of an
+      #   asset and the territories where each owner has ownership.
+      #   General  asset ownership is used for all types of assets and is the
+      #   only type  of ownership data that can be provided for assets that are
+      #   not compositions.
+      def general_owners
+        @general_owners ||= as_owners @data['general']
+      end
+
+      # @return [Array<RightOwner>] a list that identifies owners of the
+      #   performance rights for a composition asset.
+      def performance_owners
+        @performance_owners ||= as_owners @data['performance']
+      end
+
+      # @return [Array<RightOwner>] a list that identifies owners of the
+      #   synchronization rights for a composition asset.
+      def synchronization_owners
+        @synchronization_owners ||= as_owners @data['synchronization']
+      end
+
+      # @return [Array<RightOwner>] a list that identifies owners of the
+      #   mechanical rights for a composition asset.
+      def mechanical_owners
+        @mechanical_owners ||= as_owners @data['mechanical']
+      end
+
+    private
+
+      # @see https://developers.google.com/youtube/partner/docs/v1/ownership/update
+      def update_params
+        super.tap do |params|
+          params[:expected_response] = Net::HTTPOK
+          params[:path] = "/youtube/partner/v1/assets/#{@asset_id}/ownership"
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
+        end
+      end
+
+      def as_owners(data)
+        (data || []).map{|owner_data| Yt::RightOwner.new data: owner_data}
+      end
+    end
+  end
+end

data/lib/yt/models/reference.rb

@@ -196,7 +196,7 @@ module Yt
         super.tap do |params|
           params[:expected_response] = Net::HTTPOK
           params[:path] = "/youtube/partner/v1/references/#{id}"
-          params[:params] = {onBehalfOfContentOwner: @auth.owner_name}
+          params[:params] = {on_behalf_of_content_owner: @auth.owner_name}
         end
       end
     end

data/lib/yt/models/request.rb

@@ -15,7 +15,6 @@ module Yt
     class Request
       def initialize(options = {})
         @auth = options[:auth]
-        @body = options[:body]
         @file = options[:file]
         @body_type = options.fetch :body_type, :json
         @expected_response = options.fetch :expected_response, Net::HTTPSuccess
@@ -24,9 +23,14 @@ module Yt
         @host = options.fetch :host, google_api_host
         @method = options.fetch :method, :get
         @path = options[:path]
-        @query = options.fetch(:params, {}).to_param
+        @body = options[:body]
+        camelize_keys! @body if options.fetch(:camelize_body, true)
+        params = options.fetch :params, {}
+        camelize_keys! params if options.fetch(:camelize_params, true)
+        @query = params.to_param
       end
 
+
       def run
         p as_curl if Yt.configuration.developing?
 
@@ -132,6 +136,13 @@ module Yt
         end if body
       end
 
+      def camelize_keys!(object)
+        return object unless object.is_a?(Hash)
+        object.dup.each_key do |key|
+          object[key.to_s.camelize(:lower).to_sym] = object.delete key
+        end
+      end
+
       # There are two cases to run a request again: YouTube responds with a
       # random error that can be fixed by waiting for some seconds and running
       # the exact same query, or the access token needs to be refreshed.

data/lib/yt/models/resource.rb

@@ -80,12 +80,6 @@ module Yt
         part[:required] || (part[:keys] & attributes.keys).any?
       end
 
-      # If we dropped support for ActiveSupport 3, then we could simply
-      # invoke transform_keys!{|key| key.to_s.underscore.to_sym}
-      def underscore_keys!(hash)
-        hash.dup.each_key{|key| hash[underscore key] = hash.delete key}
-      end
-
       # @return [Hash] the original hash with angle brackets characters in its
       #   values replaced with similar Unicode characters accepted by Youtube.
       # @see https://support.google.com/youtube/answer/57404?hl=en
@@ -100,10 +94,6 @@ module Yt
       def camelize(value)
         value.to_s.camelize(:lower).to_sym
       end
-
-      def underscore(value)
-        value.to_s.underscore.to_sym
-      end
     end
   end
 end