vm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cbaeadd587bbcc3fa20ecfd6fc23809e23b007b5
+  data.tar.gz: 415868943231eaa92470cf7c82bc6917e5b3095b
+SHA512:
+  metadata.gz: f0830e6dfcd0c8c782c1162d18b947ba859fe62d6b761160d8ed2bca801874c2673461b1f99660b8988a49b04300d65de012c7a119d9411a990978752d5ecfd4
+  data.tar.gz: 6737623686841b59b7ba8688bc545cd615e6c27b8ec5b8852bf9e72948a2684103a82cebb57c05686d02670d2ab87929cb948677dc71c7fa2703756139fe5b81

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,211 @@
+Vm
+======
+
+Vm lets you interact with many resources provided by Vimeo API V3.
+
+[![Build Status](https://travis-ci.org/claudiob/vm.png?branch=master)](https://travis-ci.org/claudiob/vm)
+[![Code Climate](https://codeclimate.com/github/claudiob/vm.png)](https://codeclimate.com/github/claudiob/vm)
+[![Coverage Status](https://coveralls.io/repos/claudiob/vm/badge.png)](https://coveralls.io/r/claudiob/vm)
+[![Dependency Status](https://gemnasium.com/claudiob/vm.png)](https://gemnasium.com/claudiob/vm)
+
+
+```ruby
+channel = Vm::VimeoResource.new url: 'vimeo.com/remhq'
+channel.id #=> 'UC7eaRqtonpyiYw0Pns0Au_g'
+channel.title #=> "remhq"
+channel.description #=> "R.E.M.'s Official Vimeo Channel"
+```
+
+```ruby
+video = Vm::VimeoResource.new url: 'youtu.be/Kd5M17e7Wek'
+video.id #=> 'Kd5M17e7Wek'
+video.title #=> "R.E.M. - Tongue (Video)"
+video.description #=> "© 2006 WMG\nTongue (Video)"
+```
+
+```ruby
+account = Vm::VimeoAccount.new auth_params
+account.email #=> 'user@google.com'
+```
+
+```ruby
+account = Vm::VimeoAccount.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/claudiob/vm/master/frames).
+
+Available classes
+=================
+
+Vm exposes three different resources provided by Vimeo API V3:
+Vimeo Accounts, Vimeo Accounts and Vimeo Resources.
+
+Vimeo accounts
+---------------
+
+Use `Vm::VimeoAccount` to send and retrieve data to Vimeo,
+impersonating an existing Vimeo account. Available methods:
+
+* `email`: returns the email of a Vimeo account
+* `name`: returns the name of a Vimeo account
+
+These methods require user authentication (see below).
+
+Vimeo accounts
+----------------
+
+Use `Vm::VimeoAccount` to send and retrieve data to Vimeo,
+impersonating an existing Vimeo account. Available methods:
+
+* `perform!`: executes promotion actions such as: liking a video, subscribing to a channel
+
+These methods require user authentication (see below).
+
+Vimeo resources
+-----------------
+
+Use `Vm::VimeoResource` to retrieve read-only information about
+public Vimeo channels and videos. Available methods:
+
+* `id`: returns the unique identifier of a Vimeo channel/video
+* `title`: returns the title of a Vimeo channel/video
+* `description`: returns the description of a Vimeo channel/video
+* `thubmnail_url`: returns the URL of the thumbnail of a Vimeo channel/video
+
+These methods require do not require user authentication.
+
+Authentication
+==============
+
+In order to use Vm you must register your app in the [Vimeo Developers Console](https://console.developers.google.com):
+
+1. Create a new app and enable access to Vimeo+ API and Vimeo 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 Vm:
+
+```ruby
+require 'vm'
+Vm.authenticate_with client_id: '...', client_secret: '...', server_key: '...'
+```
+
+replacing the ellipses with the values from the Vimeo Developers Console.
+
+For actions that impersonate a Vimeo or Vimeo 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 Vimeo's OAuth login page. The URL is:
+
+    ```ruby
+    Vm::VimeoAccount.oauth_url(url) # to impersonate a Vimeo Account
+    Vm::VimeoAccount.oauth_url(url) # to impersonate a Vimeo 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 = Vm::VimeoAccount.new(code: code, redirect_uri: url) # to impersonate a Vimeo Account
+    account = Vm::VimeoAccount.new(code: code, redirect_uri: url) # to impersonate a Vimeo 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 = Vm::VimeoAccount.new(refresh_token: refresh_token) # to impersonate a Vimeo Account
+    account = Vm::VimeoAccount.new(refresh_token: refresh_token) # to impersonate a Vimeo Account
+    ```
+
+Remember that the redirect URL you use in the app must also be registered in
+the Vimeo Developers Console.
+Also, remember to set a Product name for your app in the Vimeo Developers
+Console, under API & Auth > Consent screen.
+
+How to install
+==============
+
+To install on your system, run
+
+  gem install vm
+
+To use inside a bundled Ruby project, add this line to the Gemfile:
+
+  gem 'vm', '~> 0.1.0'
+
+The vm gem follows [Semantic Versioning](http://semver.org).
+Any new release that is fully backward-compatible bumps the *patch* version (0.0.x).
+Any new version that breaks compatibility bumps the *minor* version (0.x.0)
+
+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 Vm is released.
+
+Why you should use Vm…
+--------------------------
+
+… and not [vimeo_it](https://github.com/kylejginavan/vimeo_it)?
+Because vimeo_it does not support Vimeo API V3 and the previous version
+has already been deprecated by Vimeo and will soon be dropped.
+
+… and not [Vimeo Api Client](https://github.com/google/google-api-ruby-client)?
+Because Vimeo Api Client is poorly coded, poorly documented and adds many
+dependencies, bloating the size of your project.
+
+… and not your own code? Because Vm is fully tested, well documented,
+has few dependencies and helps you forget about the burden of dealing with
+Vimeo API!
+
+How to test
+===========
+
+To run the tests, you must give the test app permissions to access your
+Vimeo and Vimeo accounts. They are free, so feel free to create a fake one.
+
+1. Run the following commands in a ruby session:
+
+    ```ruby
+    require 'vm'
+    Vm::VimeoAccount.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 = Vm::VimeoAccount.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 VimeoAccount with VimeoAccount to authorize access to your Vimeo 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
+=================
+
+Don’t hesitate to send code comments, issues or pull requests through GitHub!
+
+All feedback is appreciated. A [vm](http://en.wikipedia.org/wiki/Vm) of thanks! :)

data/lib/vm.rb

@@ -0,0 +1,3 @@
+require 'vm/google_account'
+require 'vm/vimeo_account'
+require 'vm/vimeo_resource'

data/lib/vm/authenticable.rb

@@ -0,0 +1,96 @@
+require 'uri'
+require 'cgi'
+require 'vm/client_tokens'
+require 'vm/requestable'
+
+module Vm
+  # Provides methods to authenticate as an account (either Vimeo or Vimeo).
+  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 Vimeo 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 Vimeo 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 Vimeo 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 Vimeo 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/vm/client_tokens.rb

@@ -0,0 +1,22 @@
+module Vm
+  module ClientTokens
+    @@client_id =  '461491672627.apps.googleusercontent.com'
+    @@client_secret =	'qXRBFZyL9X0NHMEJ_9ItefC3'
+
+    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/vm/google_account.rb

@@ -0,0 +1,74 @@
+require 'vm/authenticable'
+
+module Vm
+  # Provides read & write access to a Vimeo (or Vimeo+) account.
+  #
+  # @example Retrieve the email and given name of a Vimeo 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:
+  #
+  #       Vm::VimeoAccount.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 VimeoAccount and retrieve information:
+  #
+  #       account = Vm::VimeoAccount.new code: code, redirect_url: redirect_url
+  #       account.email # => 'user@example.com'
+  #       account.given_name # => 'Example user'
+  #
+  class VimeoAccount
+    include Authenticable
+    # Return the profile info of a Vimeo 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 Vimeo 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 Vimeo 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 Vimeo user profile and email
+    #
+    # @see https://developers.google.com/+/api/oauth#profile
+    def self.oauth_scopes
+      %w(profile email)
+    end
+  end
+end

data/lib/vm/readable.rb

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

data/lib/vm/requestable.rb

@@ -0,0 +1,58 @@
+require 'uri'
+require 'json'
+
+module Vm
+  # A custom class to rescue errors from interacting with Vimeo V3 API
+  class RequestError < StandardError
+  end
+
+  # Provides methods to send HTTP requests to Vimeo V3 API
+  module Requestable
+    ##
+    # Executes an HTTP request against the Vimeo V3 API and returns the
+    # parsed result or raise an error in case of failure
+    #
+    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/vm/server_tokens.rb

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

data/lib/vm/version.rb

@@ -0,0 +1,3 @@
+module Vm
+  VERSION = '0.0.1'
+end

data/lib/vm/vimeo_account.rb

@@ -0,0 +1,78 @@
+require 'vm/authenticable'
+require 'vm/readable'
+
+module Vm
+  # Provides read & write access to a Vimeo account (also known as Channel).
+  #
+  # @example Like the video "Tongue" by R.E.M. as a specific Vimeo 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:
+  #
+  #       Vm::VimeoAccount.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 VimeoAccount and like the video:
+  #
+  #       account = Vm::VimeoAccount.new code: code, redirect_url: redirect_url
+  #       account.perform! :like, :video, 'Kd5M17e7Wek' # => likes the video
+  #
+  class VimeoAccount
+    include Authenticable
+    include Readable
+    # Return the profile info of a Vimeo account/channel.
+    #
+    # @see https://developers.google.com/vimeo/v3/docs/channels#resource
+    #
+    # @return [Hash]
+    #   * :id [String] The ID that Vimeo uses to uniquely identify the channel.
+    #   * :etag [String] The Etag of this resource.
+    #   * :kind [String] The value will be vimeo#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: '/vimeo/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 Vimeo target resource on this Vimeo 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] = "/vimeo/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] = '/vimeo/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 Vimeo account
+    #
+    # @see https://developers.google.com/vimeo/v3/guides/authentication
+    def self.oauth_scopes
+      %w(https://www.googleapis.com/auth/vimeo)
+    end
+  end
+end

data/lib/vm/vimeo_resource.rb

@@ -0,0 +1,86 @@
+require 'vm/requestable'
+require 'vm/readable'
+require 'vm/server_tokens'
+
+module Vm
+  # Provides read-only access to a Vimeo resource (a channel or a video).
+  #
+  # @example Get the description of the video "Tongue" by R.E.M.:
+  #
+  #       resource = Vm::VimeoResource.new url: 'youtu.be/Kd5M17e7Wek'
+  #       resource.description # => "© 2006 WMG\nTongue (Video)"
+  #
+  # @example Get the description of the R.E.M. channel:
+  #
+  #       resource = Vm::VimeoResource.new url: 'vimeo.com/remhq'
+  #       resource.description # => "R.E.M.'s Official Vimeo Channel"
+  #
+  # Note that this class does not require the user to authenticate.
+  #
+  class VimeoResource
+    include Requestable
+    include Readable
+    include ServerTokens
+    # Initialize a resource by URL
+    #
+    # @param [Hash] attrs
+    # @option attrs [String] :url The URL of the Vimeo channel or video
+    def initialize(attrs = {})
+      @url = attrs[:url]
+    end
+
+    # Return the profile info of a Vimeo account/channel.
+    #
+    # @see https://developers.google.com/vimeo/v3/docs/channels#resource
+    #
+    # @return [Hash]
+    #   * :id [String] The ID that Vimeo uses to uniquely identify the channel.
+    #   * :etag [String] The Etag of this resource.
+    #   * :kind [String] The value will be vimeo#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: "/vimeo/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 Vimeo 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 Vimeo URL: #{@url}"
+      end + "&part=id,snippet&key=#{server_key}"
+    end
+
+    # Parses a URL to find the type and identifier of a Vimeo resource
+    def regex?(key)
+      host, name = '^(?:https?://)?(?:www\.)?', '([a-zA-Z0-9_-]+)'
+      case key
+        when :video_id then %r{#{host}vimeo\.com/watch\?v=#{name}}
+        when :video_short_id then %r{#{host}youtu\.be/#{name}}
+        when :channel_id then %r{#{host}vimeo\.com/channel/#{name}}
+        when :channel_username then %r{#{host}vimeo\.com/user/#{name}}
+        when :channel_name then %r{#{host}vimeo\.com/#{name}}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: vm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- claudiob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-14 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: Vimeo API client.
+email:
+- claudiob@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/vm.rb
+- lib/vm/authenticable.rb
+- lib/vm/client_tokens.rb
+- lib/vm/google_account.rb
+- lib/vm/readable.rb
+- lib/vm/requestable.rb
+- lib/vm/server_tokens.rb
+- lib/vm/version.rb
+- lib/vm/vimeo_account.rb
+- lib/vm/vimeo_resource.rb
+homepage: https://github.com/claudiob/vm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+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: Vm lets you interact with many resources provided by Vimeo API.
+test_files: []
+has_rdoc: