googol 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6945690068a1360419e43033caf75ed53ee0d231
+  data.tar.gz: 20ad10bdfe492d8bdbbc356c5c2b4d5758b83c07
+SHA512:
+  metadata.gz: 4e674a9f13fa33db3184969ba36b02df88230165fdef7a67679a2622d6a8fc2dd919edd28f16c2fc7f9cef6f0a8f06d7cb56db58828d6a3020c26cb0292ab241
+  data.tar.gz: 4e73ed288bb6b2fe9ea416cbad761c82fac7e58816b18b3257bc4c18d153390276612606fc886c54f395be40b0a193784580cdbfd23376be95b6e056f74856af

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Fullscreen, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,234 @@
+Googol
+======
+
+Googol lets you interact with many resources provided by Google API V3.
+
+[![Gem Version](https://badge.fury.io/rb/googol.svg)](http://badge.fury.io/rb/googol)
+[![Dependency Status](https://gemnasium.com/fullscreeninc/googol.png)](https://gemnasium.com/fullscreeninc/googol)
+[![Build Status](https://travis-ci.org/fullscreeninc/googol.png?branch=master)](https://travis-ci.org/fullscreeninc/googol)
+[![Coverage Status](https://coveralls.io/repos/fullscreeninc/googol/badge.png)](https://coveralls.io/r/fullscreeninc/googol)
+[![Code Climate](https://codeclimate.com/github/fullscreeninc/googol.png)](https://codeclimate.com/github/fullscreeninc/googol)
+
+
+```ruby
+channel = Googol::YoutubeResource.new url: 'youtube.com/remhq'
+channel.id #=> 'UC7eaRqtonpyiYw0Pns0Au_g'
+channel.title #=> "remhq"
+channel.description #=> "R.E.M.'s Official YouTube Channel"
+```
+
+```ruby
+video = Googol::YoutubeResource.new url: 'youtu.be/Kd5M17e7Wek'
+video.id #=> 'Kd5M17e7Wek'
+video.title #=> "R.E.M. - Tongue (Video)"
+video.description #=> "© 2006 WMG\nTongue (Video)"
+```
+
+```ruby
+account = Googol::GoogleAccount.new auth_params
+account.email #=> 'user@google.com'
+```
+
+```ruby
+account = Googol::YoutubeAccount.new auth_params
+account.perform! :like, :video, 'Kd5M17e7Wek' # => adds 'Tongue' to your 'Liked videos'
+account.perform! :subscribe_to, :channel, 'UC7eaRqtonpyiYw0Pns0Au_g' # => subscribes to R.E.M.’s channel
+```
+
+The full documentation is available at [rubydoc.info](http://rubydoc.info/github/fullscreeninc/googol/master/frames).
+
+Available classes
+=================
+
+Googol exposes three different resources provided by Google API V3:
+Google Accounts, Youtube Accounts and Youtube Resources.
+
+Google accounts
+---------------
+
+Use `Googol::GoogleAccount` to send and retrieve data to Google,
+impersonating an existing Google account.
+
+Available instance methods are `id`, `email`, `verified_email`, `name`,
+`given_name`, `family_name`, `link`, `picture`, `gender`, `locale`, and `hd`.
+
+These methods require user authentication (see below).
+
+Youtube accounts
+----------------
+
+Use `Googol::YoutubeAccount` to send and retrieve data to Youtube,
+impersonating an existing Youtube account.
+
+Available instance methods are `id`, `title`, `description`, and `thumbnail_url`.
+
+Additionally, the `perform!` method lets you executes promotional actions as
+a Youtube account, such as liking a video or subscribing to a channel.
+
+These methods require user authentication (see below).
+
+Youtube resources
+-----------------
+
+Use `Googol::YoutubeResource` to retrieve read-only information about
+public Youtube channels and videos.
+
+Available instance methods are `id`, `title`, `description`, and `thumbnail_url`.
+
+These methods require do not require user authentication.
+
+Authentication
+==============
+
+In order to use Googol you must register your app in the [Google Developers Console](https://console.developers.google.com):
+
+1. Create a new app and enable access to Google+ API and YouTube Data API V3
+1. Generate a new OAuth client ID (web application) and write down the `client ID` and `client secret`
+1. Generate a new Public API access key (for server application) and write down the `server key`
+
+Run the following command to make these tokens available to Googol:
+
+```ruby
+require 'googol'
+Googol::ClientTokens.client_id = '…'
+Googol::ClientTokens.client_secret = '…'
+Googol::ServerTokens.server_key = '…'
+```
+
+replacing the ellipses with the values from the Google Developers Console.
+
+For actions that impersonate a Google or Youtube account, you also need to
+obtain authorization from the owner of the account you wish to impersonate:
+
+1. In your web site, add a link to the Google's OAuth login page. The URL is:
+
+    ```ruby
+    Googol::GoogleAccount.oauth_url(redirect_url) # to impersonate a Google Account
+    Googol::YoutubeAccount.oauth_url(redirect_url) # to impersonate a Youtube Account
+    ```
+
+1. Upon authorization, the user is redirected to the URL passed as an argument, with an extra 'code' query parameter which can be used to impersonate the account:
+
+    ```ruby
+    account = Googol::GoogleAccount.new(code: code, redirect_uri: url) # to impersonate a Google Account
+    account = Googol::YoutubeAccount.new(code: code, redirect_uri: url) # to impersonate a Youtube Account
+    ```
+
+1. To prevent the user from having to authorize the app every time, store the account’s refresh_token in your database:
+
+    ```ruby
+    refresh_token = account.credentials[:refresh_token] # Store to your DB
+    ```
+
+1. To impersonate an account that has already authorized your app, just use the refresh_token:
+
+    ```ruby
+    account = Googol::GoogleAccount.new(refresh_token: refresh_token) # to impersonate a Google Account
+    account = Googol::YoutubeAccount.new(refresh_token: refresh_token) # to impersonate a Youtube Account
+    ```
+
+Remember to add every redirect URL that you plan to use in the Google Developers
+Console, and to set a *Product name* in Consent screen (under API & Auth).
+
+How to install
+==============
+
+To install on your system, run
+
+    gem install googol
+
+To use inside a bundled Ruby project, add this line to the Gemfile:
+
+    gem 'googol', '~> 0.1.0'
+
+Since the gem follows [Semantic Versioning](http://semver.org),
+indicating the full version in your Gemfile (~> *major*.*minor*.*patch*)
+guarantees that your project won’t occur in any error when you `bundle update`
+and a new version of Googol is released.
+
+Remember that you need to set up a Google app and include its credentials
+in order for the gem to work (see above). In a Rails project, for instance,
+you can do so by writing the following code in `config/initializer/googol.rb`:
+
+    Googol::ClientTokens.client_id = '…'
+    Googol::ClientTokens.client_secret = '…'
+    Googol::ServerTokens.server_key = '…'
+
+replacing the ellipses with your app values from the Google Developers Console.
+
+
+Why you should use Googol…
+--------------------------
+
+… and not [youtube_it](https://github.com/kylejginavan/youtube_it)?
+Because youtube_it does not support Google API V3 and the previous version
+has already been deprecated by Google and will soon be dropped.
+
+… and not [Google Api Client](https://github.com/google/google-api-ruby-client)?
+Because Google Api Client is poorly coded, poorly documented and adds many
+dependencies, bloating the size of your project.
+
+… and not your own code? Because Googol is fully tested, well documented,
+has few dependencies and helps you forget about the burden of dealing with
+Google API!
+
+How to test
+===========
+
+To run the tests, you must give the test app permissions to access your
+Google and Youtube accounts. They are free, so feel free to create a fake one.
+
+1. Run the following commands in a ruby session:
+
+    ```ruby
+    require 'googol'
+    Googol::GoogleAccount.oauth_url  # => "https://accounts.google.com/o..."
+    ```
+
+1. Copy the last URL in a browser, and accept the terms. You will be redirected to a URL like http://example.com/?code=ABCDE
+
+1. Copy the `code` parameter (ABCDE in the example above) and run:
+
+    ```ruby
+    account = Googol::GoogleAccount.new code: 'ABCDE'
+    account.credentials[:refresh_token]
+    ```
+
+1. Copy the token returned by the last command (something like 1AUJZh2x1...) and store it in an environment variable before running the test suite:
+
+    ```ruby
+    export GOOGOL_TEST_GOOGLE_REFRESH_TOKEN="1AUJZh2x1..."
+    ```
+
+1. Repeat all the steps above replacing GoogleAccount with YoutubeAccount to authorize access to your Youtube account:
+
+    ```ruby
+    export GOOGOL_TEST_YOUTUBE_REFRESH_TOKEN="2B6T5x23..."
+    ```
+
+1. Finally run the tests running `rspec` or `rake`. If you prefer not to set environment variables, pass the refresh token in the same line:
+
+    ```ruby
+    GOOGOL_TEST_GOOGLE_REFRESH_TOKEN="1AUJZh2x1..." GOOGOL_TEST_YOUTUBE_REFRESH_TOKEN="2B6T5x23..." rspec
+    ```
+
+How to contribute
+=================
+
+Before you submit a pull request, make sure all the tests are passing and the
+code is fully test-covered.
+
+To release an updated version of the gem to Rubygems, run:
+
+    rake release
+
+Remember to *bump the version* before running the command, and to document
+your changes in HISTORY.md and README.md if required.
+
+The googol gem follows [Semantic Versioning](http://semver.org).
+Any new release that is fully backward-compatible should bump the *patch* version (0.0.x).
+Any new version that breaks compatibility should bump the *minor* version (0.x.0)
+
+
+Don’t hesitate to send code comments, issues or pull requests through GitHub!
+All feedback is appreciated. A [googol](http://en.wikipedia.org/wiki/Googol) of thanks! :)

data/lib/googol.rb

@@ -0,0 +1,3 @@
+require 'googol/google_account'
+require 'googol/youtube_account'
+require 'googol/youtube_resource'

data/lib/googol/authenticable.rb

@@ -0,0 +1,96 @@
+require 'uri'
+require 'cgi'
+require 'googol/client_tokens'
+require 'googol/requestable'
+
+module Googol
+  # Provides methods to authenticate as an account (either Google or Youtube).
+  module Authenticable
+    include ClientTokens
+    include Requestable
+
+    # Initialize an object with either an authorization code or a refresh token
+    #
+    # @see https://developers.google.com/accounts/docs/OAuth2
+    #
+    # @param [Hash] attrs Authentication credentials to access the account
+    # @option attrs [String] :code The OAuth2 authorization code
+    # @option attrs [String] :redirect_url The page to redirect after the OAuth2 page
+    # @option attrs [String] :refresh_token The refresh token for offline access
+    def initialize(attrs = {})
+      @code = attrs[:code]
+      @refresh_token = attrs[:refresh_token]
+      @redirect_url = attrs.fetch :redirect_url, 'http://example.com/'
+    end
+
+    # Return the authorization credentials of an account for this app.
+    #
+    # @see ...
+    #
+    # @return [Hash]
+    #   * :client_id [String] ...
+    #   * :client_secret [String] ...
+    #   * ...
+    def credentials
+      @credentials ||= request! method: :post,
+        host: 'https://accounts.google.com',
+        path: '/o/oauth2/token',
+        body: credentials_params,
+        valid_if: -> response, body {response.code == '200'}
+    end
+
+  private
+
+    # Provides the credentials to access Google API as an authorized user.
+    #
+    # There are ways to do this:
+    # - For first-time users (who do not have a refresh token but only an
+    #   authorization code): the code is submitted to Google to obtain an
+    #   access token (to use immediately) and a refresh_token
+    # - For existing users (who have a refresh token): the refresh token is
+    #   submitted to Google to obtain a new access token
+    def credentials_params
+      if @refresh_token
+        {grant_type: :refresh_token, refresh_token: @refresh_token}
+      else
+        {grant_type: :authorization_code, code: @code, redirect_uri: @redirect_url}
+      end.merge client_id: client_id, client_secret: client_secret
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      include ClientTokens
+      # Returns the URL for users to authorize this app to access their account
+      #
+      # @param [String] redirect_url The page to redirect after the OAuth2 page
+      #
+      # @return [String] URL of the OAuth2 Authorization page.
+      #
+      # @note The redirect_url *must* match one of the redirect URLs whitelisted
+      #       for the app in the Google Developers Console
+      #
+      # @see https://console.developers.google.com
+      def oauth_url(redirect_url = 'http://example.com/')
+        params = {
+          client_id: client_id,
+          scope: oauth_scopes.join(' '),
+          redirect_uri: redirect_url,
+          response_type: :code,
+          access_type: :offline,
+          approval_prompt: :force
+        }
+        q = params.map{|k,v| "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"}.join '&'
+        args = {host: 'accounts.google.com', path: '/o/oauth2/auth', query: q}
+        URI::HTTPS.build(args).to_s
+      end
+
+      # Set the scopes to grant access to an account.
+      # This method is meant to be overridden.
+      def oauth_scopes
+      end
+    end
+  end
+end

data/lib/googol/client_tokens.rb

@@ -0,0 +1,19 @@
+module Googol
+  module ClientTokens
+    def client_id
+      @@client_id
+    end
+
+    def client_secret
+      @@client_secret
+    end
+
+    def self.client_id=(client_id)
+      @@client_id = client_id
+    end
+
+    def self.client_secret=(client_secret)
+      @@client_secret = client_secret
+    end
+  end
+end

data/lib/googol/google_account.rb

@@ -0,0 +1,74 @@
+require 'googol/authenticable'
+
+module Googol
+  # Provides read & write access to a Google (or Google+) account.
+  #
+  # @example Retrieve the email and given name of a Google account:
+  #   * Set up two pages: one with a link to authenticate, one to redirect to
+  #   * In the first page, add a link to the authentication page:
+  #
+  #       Googol::GoogleAccount.oauth_url(redirect_url)
+  #
+  #   * The user authenticates and lands on the second page, with an extra +code+ query parameter
+  #   * Use the authorization code to initialize the GoogleAccount and retrieve information:
+  #
+  #       account = Googol::GoogleAccount.new code: code, redirect_url: redirect_url
+  #       account.email # => 'user@example.com'
+  #       account.given_name # => 'Example user'
+  #
+  class GoogleAccount
+    include Authenticable
+    # Return the profile info of a Google account in OpenID Connect format.
+    #
+    # @see https://developers.google.com/+/api/latest/people/getOpenIdConnect
+    #
+    # @return [Hash]
+    #   * :id [String] The ID of the authenticated account
+    #   * :email [String] The account’s email address.
+    #   * :verified_email [String] Boolean flag which is true if the email address is verified.
+    #   * :name [String] The account’s full name.
+    #   * :given_name [String] The account’s given (first) name.
+    #   * :family_name [String] The account’s family (last) name.
+    #   * :link [String] The URL of the account’s profile page.
+    #   * :picture [String] The URL of the account’s profile picture.
+    #   * :gender [String] The account’s gender
+    #   * :locale [String] The account’s preferred locale.
+    #   * :hd [String] The hosted domain name for the accounts’s Google Apps.
+    def info
+      @info ||= request! method: :get,
+        auth: credentials[:access_token],
+        host: 'https://www.googleapis.com',
+        path: '/oauth2/v2/userinfo',
+        valid_if: -> response, body {response.code == '200'}
+    end
+
+    # Define a method to return each attribute of the profile separately.
+    #
+    # @macro [attach] attribute.name
+    #   @method $1()
+    #   Return the $1 attribute of the Google Account.
+    #
+    def self.attribute(name)
+      define_method(name) { info[name] }
+    end
+
+    attribute :id
+    attribute :email
+    attribute :verified_email
+    attribute :name
+    attribute :given_name
+    attribute :family_name
+    attribute :link
+    attribute :picture
+    attribute :gender
+    attribute :locale
+    attribute :hd
+
+    # Set the scopes to grant access to Google user profile and email
+    #
+    # @see https://developers.google.com/+/api/oauth#profile
+    def self.oauth_scopes
+      %w(profile email)
+    end
+  end
+end

data/lib/googol/readable.rb

@@ -0,0 +1,30 @@
+module Googol
+  # Provides methods to read attributes for public objects (accounts, videos..)
+  module Readable
+
+    # Return the unique Youtube identifier of a Youtube object
+    def id
+      info[:id]
+    end
+
+    # Return the title of a Youtube object
+    def title
+      info[:snippet][:title]
+    end
+
+    # Return the description of a Youtube object
+    def description
+      info[:snippet][:description]
+    end
+
+    # Return the URL of the Youtube object thumbnail
+    def thumbnail_url
+      info[:snippet][:thumbnails][:default][:url]
+    end
+
+    # Return the kind of the Youtube object (either 'channel' or 'video')
+    def kind
+      info.fetch(:kind, '').split("#").last
+    end
+  end
+end

data/lib/googol/requestable.rb

@@ -0,0 +1,60 @@
+require 'uri'
+require 'json'
+
+module Googol
+  # A custom class to rescue errors from interacting with Google V3 API
+  class RequestError < StandardError
+  end
+
+  # Provides methods to send HTTP requests to Google V3 API
+  module Requestable
+    ##
+    # Executes an HTTP request against the Google V3 API and returns the
+    # parsed result or raise an error in case of failure
+    #
+    # @note Not the best code quality, feel free to refactor!
+    #
+    def request!(params = {})
+      url = URI.parse params[:host]
+      http = Net::HTTP.new url.host, url.port
+      http.use_ssl = true
+      request = case params[:method]
+        when :get then Net::HTTP::Get.new params[:path]
+        when :post then
+          if params[:json]
+            Net::HTTP::Post.new params[:path], initheader = {'Content-Type' =>'application/json'}
+          else
+            Net::HTTP::Post.new params[:path]
+          end
+      end
+      if params[:json]
+        request.body = params[:body].to_json
+      else
+        request.set_form_data params[:body]
+      end if params[:body]
+
+      request['Authorization'] = 'Bearer ' + params[:auth] if params[:auth]
+      response = http.request(request)
+
+      body = JSON.parse response.body if response.body
+
+      if params[:valid_if] ? params[:valid_if].call(response, body) : true
+        body = params[:extract].call body if params[:extract]
+        body ? deep_symbolize_keys(body) : true
+      else
+        raise RequestError, body
+      end
+    end
+
+  private
+
+    def deep_symbolize_keys(hash)
+      {}.tap do |result|
+        hash.each do |k, v|
+          key = k.to_sym rescue k
+          result[key] = v.is_a?(Hash) ? deep_symbolize_keys(v) : v
+        end
+      end
+    end
+  end
+end

data/lib/googol/server_tokens.rb

@@ -0,0 +1,11 @@
+module Googol
+  module ServerTokens
+    def server_key
+      @@server_key
+    end
+
+    def self.server_key=(server_key)
+      @@server_key = server_key
+    end
+  end
+end

data/lib/googol/version.rb

@@ -0,0 +1,3 @@
+module Googol
+  VERSION = '0.1.1'
+end

data/lib/googol/youtube_account.rb

@@ -0,0 +1,78 @@
+require 'googol/authenticable'
+require 'googol/readable'
+
+module Googol
+  # Provides read & write access to a Youtube account (also known as Channel).
+  #
+  # @example Like the video "Tongue" by R.E.M. as a specific Youtube account:
+  #   * Set up two pages: one with a link to authenticate, one to redirect to
+  #   * In the first page, add a link to the authentication page:
+  #
+  #       Googol::YoutubeAccount.oauth_url(redirect_url)
+  #
+  #   * The user authenticates and lands on the second page, with an extra +code+ query parameter
+  #   * Use the authorization code to initialize the YoutubeAccount and like the video:
+  #
+  #       account = Googol::YoutubeAccount.new code: code, redirect_url: redirect_url
+  #       account.perform! :like, :video, 'Kd5M17e7Wek' # => likes the video
+  #
+  class YoutubeAccount
+    include Authenticable
+    include Readable
+    # Return the profile info of a Youtube account/channel.
+    #
+    # @see https://developers.google.com/youtube/v3/docs/channels#resource
+    #
+    # @return [Hash]
+    #   * :id [String] The ID that YouTube uses to uniquely identify the channel.
+    #   * :etag [String] The Etag of this resource.
+    #   * :kind [String] The value will be youtube#channel.
+    #   * :snippet [Hash]
+    #     - :title [String] The channel's title.
+    #     - :description [String] The channel's description.
+    #     - :publishedAt [String] The date and time that the channel was created. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format.
+    #     - :thumbnails [Hash]
+    #       + :default [Hash] Default thumbnail URL (88px x 88px)
+    #       + :medium [Hash] Medium thumbnail URL (88px x 88px)
+    #       + :high [Hash] High thumbnail URL (88px x 88px)
+    def info
+      @info ||= request! method: :get,
+        auth: credentials[:access_token],
+        host: 'https://www.googleapis.com',
+        path: '/youtube/v3/channels?part=id,snippet&mine=true',
+        valid_if: -> resp, body {resp.code == '200' && body['items'].any?},
+        extract: -> body {body['items'].first}
+    end
+
+    ## Promote a Youtube target resource on this Youtube Channel
+    # Note that liking a video does not also subscribe to a channel
+    def perform!(activity, target_kind, target_id)
+      params = {}.tap do |params|
+        params[:method] = :post
+        params[:auth] = credentials[:access_token]
+        params[:host] = 'https://www.googleapis.com'
+
+        case [activity.to_sym, target_kind.to_sym]
+        when [:like, :video]
+          params[:path] = "/youtube/v3/videos/rate?rating=like&id=#{target_id}"
+          params[:valid_if] = -> response, body {response.code == '204'}
+        when [:subscribe_to, :channel]
+          params[:json] = true
+          params[:path] = '/youtube/v3/subscriptions?part=snippet'
+          params[:body] = {snippet: {resourceId: {channelId: target_id}}}
+          params[:valid_if] = -> response, body {response.code == '200'}
+        else
+          raise RequestError, "#{activity} invalid for #{target_kind} #{target_id}"
+        end
+      end
+      request! params
+    end
+
+    # Set the scopes to grant access to Youtube account
+    #
+    # @see https://developers.google.com/youtube/v3/guides/authentication
+    def self.oauth_scopes
+      %w(https://www.googleapis.com/auth/youtube)
+    end
+  end
+end

data/lib/googol/youtube_resource.rb

@@ -0,0 +1,86 @@
+require 'googol/requestable'
+require 'googol/readable'
+require 'googol/server_tokens'
+
+module Googol
+  # Provides read-only access to a Youtube resource (a channel or a video).
+  #
+  # @example Get the description of the video "Tongue" by R.E.M.:
+  #
+  #       resource = Googol::YoutubeResource.new url: 'youtu.be/Kd5M17e7Wek'
+  #       resource.description # => "© 2006 WMG\nTongue (Video)"
+  #
+  # @example Get the description of the R.E.M. channel:
+  #
+  #       resource = Googol::YoutubeResource.new url: 'youtube.com/remhq'
+  #       resource.description # => "R.E.M.'s Official YouTube Channel"
+  #
+  # Note that this class does not require the user to authenticate.
+  #
+  class YoutubeResource
+    include Requestable
+    include Readable
+    include ServerTokens
+    # Initialize a resource by URL
+    #
+    # @param [Hash] attrs
+    # @option attrs [String] :url The URL of the Youtube channel or video
+    def initialize(attrs = {})
+      @url = attrs[:url]
+    end
+
+    # Return the profile info of a Youtube account/channel.
+    #
+    # @see https://developers.google.com/youtube/v3/docs/channels#resource
+    #
+    # @return [Hash]
+    #   * :id [String] The ID that YouTube uses to uniquely identify the channel.
+    #   * :etag [String] The Etag of this resource.
+    #   * :kind [String] The value will be youtube#channel.
+    #   * :snippet [Hash]
+    #     - :title [String] The channel's title.
+    #     - :description [String] The channel's description.
+    #     - :publishedAt [String] The date and time that the channel was created. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format.
+    #     - :thumbnails [Hash]
+    #       + :default [Hash] Default thumbnail URL (88px x 88px)
+    #       + :medium [Hash] Medium thumbnail URL (88px x 88px)
+    #       + :high [Hash] High thumbnail URL (88px x 88px)
+    def info
+      @info ||= request! method: :get,
+        host: 'https://www.googleapis.com',
+        path: "/youtube/v3/#{info_path}",
+        valid_if: -> resp, body {resp.code == '200' && body['items'].any?},
+        extract: -> body {body['items'].first}
+    end
+
+  private
+
+    ##
+    # Return the path to execute the Google API request again.
+    # Channels and videos have different paths, so it depends on the type
+    #
+    # @return [String] Path
+    def info_path
+      @info_path ||= case @url
+        when regex?(:video_id) then "videos?id=#{$1}"
+        when regex?(:video_short_id) then "videos?id=#{$1}"
+        when regex?(:channel_id) then "channels?id=#{$1}"
+        when regex?(:channel_username) then "channels?forUsername=#{$1}"
+        when regex?(:channel_name) then "channels?forUsername=#{$1}"
+        else raise RequestError, "Invalid Youtube URL: #{@url}"
+      end + "&part=id,snippet&key=#{server_key}"
+    end
+
+    # Parses a URL to find the type and identifier of a Youtube resource
+    def regex?(key)
+      host, name = '^(?:https?://)?(?:www\.)?', '([a-zA-Z0-9_-]+)'
+      case key
+        when :video_id then %r{#{host}youtube\.com/watch\?v=#{name}}
+        when :video_short_id then %r{#{host}youtu\.be/#{name}}
+        when :channel_id then %r{#{host}youtube\.com/channel/#{name}}
+        when :channel_username then %r{#{host}youtube\.com/user/#{name}}
+        when :channel_name then %r{#{host}youtube\.com/#{name}}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: googol
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Claudio Baccigalupo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Google + Youtube V3 API client.
+email:
+- claudio@fullscreen.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/googol.rb
+- lib/googol/authenticable.rb
+- lib/googol/client_tokens.rb
+- lib/googol/google_account.rb
+- lib/googol/readable.rb
+- lib/googol/requestable.rb
+- lib/googol/server_tokens.rb
+- lib/googol/version.rb
+- lib/googol/youtube_account.rb
+- lib/googol/youtube_resource.rb
+homepage: https://github.com/fullscreeninc/googol
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Googol lets you interact with many resources provided by Google API V3.
+test_files: []
+has_rdoc: