yt-andrewroth 0.25.5.1

data/bin/yt

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'yt'
+rescue LoadError
+  require 'rubygems'
+  require 'yt'
+end
+
+Yt.configuration.log_level = :debug
+id = ARGV[1] || 'BPNYv0vd78A'
+
+case ARGV[0]
+when 'info'
+  puts "Yt version #{Yt::VERSION}"
+  video = Yt::Video.new id: id
+  puts video.annotations.first.text
+when 'annotations'
+  video = Yt::Video.new id: id
+  count = video.annotations.size
+  puts "Video #{id} has #{count} #{'annotation'.pluralize count}"
+  video.annotations.each.with_index do |annotation, i|
+    puts "#{i+1}) #{annotation.text}"
+  end
+when 'video'
+  video = Yt::Video.new id: id
+  views = "#{video.view_count} #{'view'.pluralize video.view_count}"
+  likes = "#{video.like_count} #{'like'.pluralize video.like_count}"
+  puts "'#{video.title}' by #{video.channel_title} has #{views} and #{likes}"
+end

data/gemfiles/Gemfile.activesupport-3.x

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gem 'activesupport', '~> 3.0'
+gemspec path: '../'

data/gemfiles/Gemfile.activesupport-4.x

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gem 'activesupport', '~> 4.0'
+gemspec path: '../'

data/lib/yt.rb

@@ -0,0 +1,21 @@
+require 'yt/config'
+require 'yt/version'
+require 'yt/models/account'
+require 'yt/models/channel'
+require 'yt/models/claim'
+require 'yt/models/claim_history'
+require 'yt/models/content_owner'
+require 'yt/models/match_policy'
+require 'yt/models/playlist'
+require 'yt/models/playlist_item'
+require 'yt/models/video'
+require 'yt/models/ownership'
+require 'yt/models/advertising_options_set'
+
+# An object-oriented Ruby client for YouTube.
+# Helps creating applications that need to interact with YouTube objects.
+# Inclused methods to access YouTube Data API V3 resources (channels, videos,
+# ...), YouTube Analytics API V2 resources (metrics, earnings, ...), and
+# objects not available through the API (annotations).
+module Yt
+end

data/lib/yt/actions/base.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+module Yt
+  # @private
+  module Actions
+    # Abstract module that contains methods common to every action
+    module Base
+
+    private
+
+      # 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
+
+      # @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
+      def sanitize_brackets!(source)
+        case source
+          when String then source.gsub('<', '‹').gsub('>', '›')
+          when Array then source.map{|string| sanitize_brackets! string}
+          when Hash then source.each{|k,v| source[k] = sanitize_brackets! v}
+        end
+      end
+    end
+  end
+end

data/lib/yt/actions/delete.rb

@@ -0,0 +1,19 @@
+require 'yt/actions/modify'
+
+module Yt
+  module Actions
+    module Delete
+      include Modify
+
+    private
+
+      def do_delete(extra_delete_params = {}, &block)
+        do_modify delete_params.merge(extra_delete_params), &block
+      end
+
+      def delete_params
+        modify_params.tap{|params| params[:method] = :delete}
+      end
+    end
+  end
+end

data/lib/yt/actions/delete_all.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+require 'yt/actions/list'
+require 'yt/request'
+
+module Yt
+  module Actions
+    module DeleteAll
+      include List
+
+    private
+
+      def do_delete_all(params = {}, options = {})
+        list_all(params).map do |item|
+          item.delete options
+        end.tap { @items = [] }
+      end
+
+      def list_all(params = {})
+        list.find_all do |item|
+          params.all? do |method, value|
+            # TODO: could be symbol etc...
+            item.respond_to?(method) && case value
+            when Regexp then item.send(method) =~ value
+            when Array then item.send(method) == value.map{|item| item.to_s.gsub('<', '‹').gsub('>', '›')}
+            else item.send(method) == value.to_s.gsub('<', '‹').gsub('>', '›')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yt/actions/insert.rb

@@ -0,0 +1,42 @@
+require 'yt/request'
+require 'yt/actions/base'
+require 'yt/config'
+
+module Yt
+  module Actions
+    module Insert
+      include Base
+
+    private
+
+      def do_insert(extra_insert_params = {})
+        response = insert_request(extra_insert_params).run
+        @items = []
+        new_item extract_data_from(response)
+      end
+
+      def insert_request(params = {})
+        Yt::Request.new(insert_params.deep_merge params).tap do |request|
+          print "#{request.as_curl}\n" if Yt.configuration.developing?
+        end
+      end
+
+      def insert_params
+        path = "/youtube/v3/#{self.class.to_s.demodulize.camelize :lower}"
+
+        {}.tap do |params|
+          params[:path] = path
+          params[:host] = 'www.googleapis.com'
+          params[:method] = :post
+          params[:auth] = @auth
+          params[:expected_response] = Net::HTTPOK
+          params[:api_key] = Yt.configuration.api_key if Yt.configuration.api_key
+        end
+      end
+
+      def extract_data_from(response)
+        response.body
+      end
+    end
+  end
+end

data/lib/yt/actions/list.rb

@@ -0,0 +1,139 @@
+require 'yt/request'
+require 'yt/models/iterator'
+require 'yt/errors/no_items'
+require 'yt/config'
+
+module Yt
+  module Actions
+    module List
+      delegate :any?, :count, :each, :each_cons, :each_slice, :find, :first,
+        :flat_map, :map, :select, :size, to: :list
+
+      def first!
+        first.tap{|item| raise Errors::NoItems, error_message unless item}
+      end
+
+    private
+
+      def list
+        @last_index, @page_token = 0, nil
+        Yt::Iterator.new(-> {total_results}) do |items|
+          while next_item = find_next
+            items << next_item
+          end
+          @where_params = {}
+        end
+      end
+
+      # Returns the total number of items that YouTube can provide for the
+      # given request, either all in one page or in consecutive pages.
+      #
+      # This number comes from the 'totalResults' component of the 'pageInfo'
+      # which, accordingly to YouTube documentation, *does not always match
+      # the actual number of items in the response*.
+      #
+      # For instance, when retrieving a list of channels, 'totalResults' might
+      # include inactive channels, which are filtered out from the response.
+      #
+      # The only way to obtain the *real* number of returned items is to
+      # iterate through all the pages, which can results in many requests.
+      # To avoid this, +total_results+ is provided as a good size estimation.
+      def total_results
+        response = list_request(list_params).run
+        total_results = response.body.fetch('pageInfo', {})['totalResults']
+        total_results ||= extract_items(response.body).size
+      end
+
+      def find_next
+        @items ||= []
+        if @items[@last_index].nil? && more_pages?
+          more_items = next_page.map{|data| new_item data}
+          @items.concat more_items
+        end
+        @items[(@last_index +=1) -1]
+      end
+
+      def resource_class
+        resource_name = list_resources.singularize
+        require "yt/models/#{resource_name.underscore}"
+        "Yt::Models::#{resource_name}".constantize
+      end
+
+      # @return [resource_class] a new resource initialized with one
+      #   of the items returned by asking YouTube for a list of resources.
+      #   Can be overwritten by subclasses that initialize instance with
+      #   a different set of parameters.
+      def new_item(data)
+        resource_class.new attributes_for_new_item(data)
+      end
+
+      # @private
+      # Can be overwritten by subclasses that initialize instance with
+      # a different set of parameters.
+      def attributes_for_new_item(data)
+        {data: data, auth: @auth}
+      end
+
+      def more_pages?
+        @last_index.zero? || !@page_token.nil?
+      end
+
+      def next_page
+        params = list_params.dup
+        params[:params][:page_token] = @page_token if @page_token
+        next_page = fetch_page params
+        @page_token = next_page[:token]
+        eager_load_items_from next_page[:items]
+      end
+
+      def eager_load_items_from(items)
+        items
+      end
+
+      def fetch_page(params = {})
+        @last_response = list_request(params).run
+        token = @last_response.body['nextPageToken']
+        items = extract_items @last_response.body
+        {items: items, token: token}
+      end
+
+      def list_request(params = {})
+        @list_request = Yt::Request.new(params).tap do |request|
+          print "#{request.as_curl}\n" if Yt.configuration.developing?
+        end
+      end
+
+      def error_message
+        {}.tap do |message|
+          message[:request_curl] = @list_request.as_curl
+          message[:response_body] = JSON(@last_response.body)
+        end.to_json if @list_request && @last_response
+      end
+
+      def list_params
+        path = "/youtube/v3/#{list_resources.camelize :lower}"
+
+        {}.tap do |params|
+          params[:method] = :get
+          params[:host] = 'www.googleapis.com'
+          params[:auth] = @auth
+          params[:path] = path
+          params[:exptected_response] = Net::HTTPOK
+          params[:api_key] = Yt.configuration.api_key if Yt.configuration.api_key
+        end
+      end
+
+      def extract_items(list)
+        list.fetch items_key, []
+      end
+
+      def items_key
+        'items'
+      end
+
+      def list_resources
+        self.class.to_s.demodulize
+      end
+    end
+  end
+end

data/lib/yt/actions/modify.rb

@@ -0,0 +1,37 @@
+require 'yt/request'
+require 'yt/actions/base'
+require 'yt/config'
+
+module Yt
+  module Actions
+    # Abstract module that contains methods common to Delete and Update
+    module Modify
+      include Base
+
+    private
+
+      def do_modify(params = {})
+        response = modify_request(params).run
+        yield response.body if block_given?
+      end
+
+      def modify_request(params = {})
+        Yt::Request.new(params).tap do |request|
+          print "#{request.as_curl}\n" if Yt.configuration.developing?
+        end
+      end
+
+      def modify_params
+        path = "/youtube/v3/#{self.class.to_s.demodulize.pluralize.camelize :lower}"
+
+        {}.tap do |params|
+          params[:path] = path
+          params[:auth] = @auth
+          params[:host] = 'www.googleapis.com'
+          params[:expected_response] = Net::HTTPNoContent
+          params[:api_key] = Yt.configuration.api_key if Yt.configuration.api_key
+        end
+      end
+    end
+  end
+end

data/lib/yt/actions/patch.rb

@@ -0,0 +1,19 @@
+require 'yt/actions/modify'
+
+module Yt
+  module Actions
+    module Patch
+      include Modify
+
+    private
+
+      def do_patch(extra_patch_params = {}, &block)
+        do_modify patch_params.deep_merge(extra_patch_params), &block
+      end
+
+      def patch_params
+        modify_params.tap{|params| params[:method] = :patch}
+      end
+    end
+  end
+end

data/lib/yt/actions/update.rb

@@ -0,0 +1,19 @@
+require 'yt/actions/modify'
+
+module Yt
+  module Actions
+    module Update
+      include Modify
+
+    private
+
+      def do_update(extra_update_params = {}, &block)
+        do_modify update_params.deep_merge(extra_update_params), &block
+      end
+
+      def update_params
+        modify_params.tap{|params| params[:method] = :put}
+      end
+    end
+  end
+end

data/lib/yt/associations/has_attribute.rb

@@ -0,0 +1,55 @@
+require 'yt/models/timestamp'
+
+module Yt
+  # @private
+  module Associations
+    # @private
+    module HasAttribute
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    private
+
+      def type_cast(value, type)
+        case [type]
+          when [Time] then Yt::Timestamp.parse(value) if value
+          when [Integer] then value.to_i if value
+          when [Float] then value.to_f if value
+          when [Symbol] then value.to_sym if value
+          when [Hash] then value || {}
+        end
+      end
+
+      module ClassMethods
+        def has_attribute(attribute, options = {}, &block)
+          define_memoized_method(attribute) do
+            field = options.fetch(:from, attribute).to_s
+            field = field.camelize(:lower) if options.fetch(:camelize, true)
+            value = @data.fetch field, options[:default]
+            value = type_cast value, options[:type] if options[:type]
+            block_given? ? instance_exec(value, &block) : value
+          end
+        end
+
+      private
+
+        # A wrapper around Ruby’s +define_method+ that, in addition to adding an
+        # instance method called +name+, adds an instance variable called +@name+
+        # that stores the result of +name+ the first time is invoked, and returns
+        # it every other time. Especially useful if invoking +name+ takes a long
+        # time.
+        def define_memoized_method(name, &method)
+          ivar_name = "@#{name.to_s.gsub /[?!]$/, ''}"
+
+          define_method name do
+            value = instance_variable_get ivar_name
+            # don't ever rely on cache; it consistently causes wrong results 
+            # (though I can't consistently reproduce the problem.. yet)
+            instance_variable_set ivar_name, instance_eval(&method)
+          end
+        end
+      end
+    end
+  end
+end