viki 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+*.DS_Store
+pkg/*
+*.swp
+*.un~
+.idea/
+fixtures/

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p125@viki-gem --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in viki.gemspec
+gemspec

data/README.md

@@ -0,0 +1,50 @@
+A Viki wrapper gem for the Viki V3 API. This gem is currently under active development.
+
+Full documentation for API V3 may be found at [dev.viki.com](http://dev.viki.com/api "Viki API V3 Docs")
+
+
+Endpoints
+----------
+
+Here are a full list of functions available.
+
+```
+client.movies(params)
+client.movies(id, params)
+  client.movie(id).subtitles(lang)
+  client.movie(id).hardsubs
+
+client.series(params)
+client.series(id, params)
+  client.series(id).episodes(params)
+  client.series(id).episodes(id)
+  client.series(id).episodes(id).subtitles(lang)
+  client.series(id).episodes(id).hardsubs
+
+client.music_videos(params)
+client.music_videos(id, params)
+  client.music_videos(id).subtitles(lang)
+  client.music_videos(id).hardsubs * implementation waiting on valid examples
+
+client.newscasts(params)
+client.newscasts(id, params)
+client.newscasts(id).newsclips
+
+
+client.newsclips
+client.newsclips(id)
+  client.newsclips(id).subtitles(lang)
+  client.newsclips(id).hardsubs(lang)
+
+
+client.artists(params)
+client.artist(id, params)
+  client.artists(id).music_videos(params)
+
+client.featured(params)
+
+client.coming_soon
+client.coming_soon.movies
+client.coming_soon.series
+```
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/viki/api_object.rb

@@ -0,0 +1,41 @@
+require 'multi_json'
+require 'viki/utilities'
+
+module Viki
+  class APIObject
+    include Viki::Utilities
+
+    def initialize(json, access_token)
+      hash = MultiJson.load(json)
+      @content = hash["response"] ?  hash["response"] : hash
+      @count =  hash["count"] ? hash["count"].to_i : 1
+
+      pagination = hash["pagination"]
+
+      if pagination
+        @next_url = pagination["next"] if not pagination["next"].empty?
+        @previous_url = pagination["previous"] if not pagination["previous"].empty?
+      end
+
+      @access_token = access_token
+    end
+
+    attr_reader :content, :count
+
+    def next
+      @next_url ? direct_request(@next_url) : nil
+    end
+
+    def prev
+      @previous_url ? direct_request(@next_url) : nil
+    end
+
+    private
+
+    def direct_request(url)
+      response = HTTParty.get(url, :query => { access_token: @access_token })
+      capture response
+      APIObject.new(response.body, @access_token)
+    end
+  end
+end

data/lib/viki/client.rb

@@ -0,0 +1,51 @@
+require 'httparty'
+require 'viki/api_object'
+require 'viki/request'
+require 'multi_json'
+
+module Viki
+  class Client
+    Dir[File.expand_path('../client/*.rb', __FILE__)].each { |f| require f }
+    URL_NAMESPACES = [:movies, :series, :episodes, :music_videos, :newscasts, :newsclips,
+            :artists, :featured, :coming_soon, :subtitles, :hardsubs]
+
+    def initialize(client_id, client_secret)
+      @client_id = client_id
+      @client_secret = client_secret
+      @access_token = auth_request(client_id, client_secret)
+    end
+
+    attr_reader :access_token
+
+    include Viki::Request
+
+    def get
+      request(@call_chain)
+    end
+
+    def reset_access_token
+      @access_token = auth_request(@client_id, @client_secret)
+    end
+
+    private
+    def method_missing(name, *args, &block)
+      @call_chain ||= []
+      raise NoMethodError if not URL_NAMESPACES.include? name
+
+      curr_call = { name: name }
+
+      first_arg, second_arg = args[0], args[1]
+
+      if args.length == 1
+        first_arg.is_a?(Hash) ? curr_call.merge!({ params: first_arg }) : curr_call.merge!({ resource: first_arg })
+      elsif args.length == 2
+        curr_call.merge!({ resource: first_arg })
+        curr_call.merge!({ params: second_arg })
+      end
+
+      @call_chain.push(curr_call)
+      self
+    end
+
+  end
+end

data/lib/viki/error.rb

@@ -0,0 +1,11 @@
+module Viki
+  class Error < StandardError
+    attr_accessor :status, :message
+
+    def initialize(status, msg=nil)
+      self.status = status
+      self.message = msg
+      super(msg||"#{self.status}: #{self.message}")
+    end
+  end
+end

data/lib/viki/request.rb

@@ -0,0 +1,57 @@
+require 'uri'
+require 'httparty'
+require 'multi_json'
+require 'viki/utilities'
+
+module Viki
+  module Request
+    include Viki::Utilities
+
+    private
+    HOST = "http://www.viki.com/api/v3/"
+
+    def auth_request(client_id, client_secret)
+      params = {
+        :grant_type => 'client_credentials',
+        :client_id => client_id,
+        :client_secret => client_secret
+      }
+      response = HTTParty.post('http://viki.com/oauth/token', query: params)
+      json = MultiJson.load(response.body)
+      raise Viki::Error.new(response.header.code, json["error_description"]) if response.header.code != "200"
+      json["access_token"]
+    end
+
+    def request(call_chain)
+      path, params = build_url(call_chain)
+      request_url = HOST + path.chop + ".json"
+
+      response = HTTParty.get(request_url, :query => params)
+
+      if response.header.code == "401"
+        self.reset_access_token
+        params.merge!({ access_token: self.access_token })
+        response = HTTParty.get(request_url, :query => params)
+      end
+
+      capture response
+
+      APIObject.new(response.body, self.access_token)
+    end
+
+    private
+
+    def build_url(call_chain)
+      path = ""
+      params = { access_token: self.access_token }
+
+      call_chain.each do |c|
+        path += "#{c[:name]}/"
+        path += "#{c[:resource]}/" if c.has_key?(:resource)
+        params.merge!(c[:params]) if c.has_key?(:params)
+      end
+
+      return path, params
+    end
+  end
+end

data/lib/viki/utilities.rb

@@ -0,0 +1,13 @@
+module Viki
+  module Utilities
+    private
+
+    def capture(response)
+      if response.header.code != "200"
+        response_hash = MultiJson.load(response.body)
+        raise Viki::Error.new(response.header.code, response_hash["message"]) if response.header.code != "200"
+      end
+    end
+
+  end
+end

data/lib/viki/version.rb

@@ -0,0 +1,3 @@
+module Viki
+  VERSION = "0.0.1"
+end

data/lib/viki.rb

@@ -0,0 +1,16 @@
+require 'viki/version'
+require 'viki/client'
+require 'viki/error'
+require 'viki/utilities'
+
+# Adapted from the Grackle Twitter gem.
+module Viki
+
+  # Alias for viki::Client.new
+  #
+  # @return {viki::Client})
+  def self.new(client_id, client_secret)
+    Viki::Client.new(client_id, client_secret)
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Viki::Client do
+
+  describe "#get" do
+    before { Viki::Client.any_instance.stub(:auth_request) }
+    subject { Viki::Client.new('chickenrice', 'soronerychickenrice') }
+
+    it "should perform a request to the right url given a call chain" do
+      subject.movies(1234).subtitles('en')
+      subject.should_receive(:request).with([{ :name => :movies, :resource => 1234 },
+                                             { :name => :subtitles, :resource => "en" }])
+      subject.get
+    end
+
+    it "should perform a request with the right params given a call chain" do
+      subject.movies(1234, {genre: 2})
+      subject.should_receive(:request).with([{ :name => :movies, :resource => 1234, :params => {genre: 2}}])
+      subject.get
+    end
+
+    it "should raise NoMethodError error if part of the call chain is not part of the URL_NAMESPACES list" do
+      expect { subject.methodwrong.subtitles('en') }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Viki::Error do
+  before { @error = Viki::Error.new(404, "Resource 'blah' not found.")}
+
+  subject { @error }
+
+  it { should respond_to(:status) }
+  it { should respond_to(:message) }
+
+  it { subject.to_s.should == "Resource 'blah' not found."}
+end

data/spec/filter_shared_examples_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+shared_examples_for "API with parameter filters" do
+  context "when filtering with genre" do
+    let(:query_options) { { :genre => 2 } }
+    it "should return a genre-filtered list of Viki::Movie objects when given genre params" do
+      VCR.use_cassette "#{type}/genre_filter" do
+        results.each do |m|
+          m.genres.each do |g|
+            g["id"].should == 2
+          end
+        end
+      end
+    end
+  end
+
+  context "when filtering with subtitle_language" do
+    let(:query_options) { { :subtitle_language => 'fr' } }
+    it "should return movies with requested subtitle > 90% completion, when given a subtitle_language parameter" do
+      VCR.use_cassette "#{type}/subtitle_language_filter" do
+        results.each do |m|
+          m.subtitles["fr"].should > 90
+        end
+      end
+    end
+  end
+
+  context "when filtering with watchable_in" do
+    let(:query_options) { { :watchable_in => 'sg' } }
+    it "should return movies watchable_in selected country when given a watchable_in parameter" do
+      VCR.use_cassette "#{type}/watchable_in_filter" do
+        results.should_not be_empty
+      end
+    end
+  end
+
+  context "when filtering with origin_country" do
+    let(:query_options) { { :origin_country => 'kr' } }
+    it "should return movies from a specific country when given a origin_country parameter" do
+      VCR.use_cassette "#{type}/origin_country_filter" do
+        results.each do |m|
+          m.origin_country.should == 'Korea'
+        end
+      end
+    end
+  end
+
+
+  context "when filtering with platform" do
+    let(:query_options) { { :platform => 'mobile' } }
+    it "should return movies available in selected platform when given watchable_in and platform parameters" do
+      query_options.merge!({ :watchable_in => 'sg' })
+      VCR.use_cassette "#{type}/platform_filter" do
+        results.should_not be_empty
+      end
+    end
+  end
+end
+
+

data/spec/request_spec.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'filter_shared_examples_spec'
+
+describe "Viki" do
+  let(:client_id) { '4bd5edd4ba26ac2f3ad9d204dc6359ea8a3ebe2c95b6bc1a9195c0ce5c57d392' }
+  let(:client_secret) { 'f3b796a1eb6e06458a502a89171a494a9160775ed4f4e9e0008c638f7e7e7d38' }
+
+  describe "Auth" do
+    it "should retrieve an access token when the Viki object is configured and initialized" do
+      VCR.use_cassette "auth" do
+        client = Viki.new(client_id, client_secret)
+        client.access_token.should == '1b080a6b3a94ed4503e04e252500ca87f6e7dc55061cec92b627ef1fbec44c70'
+      end
+    end
+
+    it "should return an error when the client_secret or client_id is incorrect" do
+      VCR.use_cassette "auth_error" do
+        lambda { Viki.new('12345', '54321') }.should raise_error(Viki::Error,
+                                                                 'Client authentication failed due to unknown client, no client authentication included, or unsupported authentication method.')
+      end
+    end
+  end
+
+  describe "API Interactions" do
+    let(:query_options) { { } }
+    let(:client) do
+      VCR.use_cassette "auth" do
+        Viki.new(client_id, client_secret)
+      end
+    end
+
+    describe "Movies" do
+      let(:results) { client.movies(query_options).get }
+      let(:type) { :movie }
+
+      describe "/movies" do
+        it "should return a list Viki::Movie objects" do
+          VCR.use_cassette "movies/list" do
+            results.content.each do |movie|
+              movie.should be_instance_of(Hash)
+            end
+          end
+        end
+
+        it "should raise an error when platform parameter is given without watchable_in" do
+          VCR.use_cassette "movie/platform_filter_error" do
+            query_options.merge!({ :platform => 'mobile' })
+            lambda { results }.should raise_error(Viki::Error,
+                                                  "Require watchable_in parameter when given platform parameter")
+          end
+        end
+
+        #it_behaves_like "API with parameter filters"
+      end
+
+      describe "/movies/:id" do
+        it "should return a Viki::Movie object" do
+          VCR.use_cassette "movie_show" do
+            response = client.movies(70436).get
+            movie = response.content
+
+            #overtesting
+            movie["id"].should == 70436
+            movie["title"].should == "Muoi: The Legend of a Portrait"
+            movie["description"].should_not be_empty
+            movie["created_at"].should_not be_empty
+            movie["uri"].should_not be_empty
+            movie["origin_country"].should_not be_empty
+            movie["image"].should_not be_empty
+            movie["formats"].should_not be_empty
+            movie["subtitles"].should_not be_empty
+            movie["genres"].should_not be_empty
+          end
+        end
+
+        it "should return a Viki::Error object when resource not found" do
+          VCR.use_cassette "movie_error" do
+            lambda { client.movies(50).get }.should raise_error(Viki::Error, "The resource couldn't be found")
+          end
+        end
+      end
+
+      describe "/movies/:id/subtitles/:lang" do
+        it "should return a subtitle JSON string" do
+          VCR.use_cassette "movies/subtitles" do
+            response = client.movies(21713).subtitles('en').get
+            response.count.should == 1
+            subtitles = response.content
+            subtitles["language_code"].should == "en"
+            subtitles["subtitles"].should_not be_empty
+          end
+        end
+      end
+
+      describe "movies/:id/hardsubs" do
+        it "should return a list of video qualities with links to hardsubbed videos" do
+          VCR.use_cassette "movies/hardsubs" do
+            response = client.movies(64135).hardsubs.get
+            response.count.should == 1
+            hardsubs = response.content
+            hardsubs["res-240p"].should_not be_empty
+          end
+        end
+      end
+
+      describe "APIObject pagination" do
+        it "returns an APIObject for APIObject containing movies when it has a next page" do
+          VCR.use_cassette "APIObject/pagination" do
+            response = client.movies.get
+            result = response.next
+            result.count.should > 1
+            result.content.should_not be_empty
+            result.should be_instance_of(Viki::APIObject)
+          end
+        end
+
+        it "returns nil if there is movies listing has no next page" do
+          VCR.use_cassette "APIObject/pagination_fail" do
+            response = client.movies({ page: 6 }).get
+            result = response.next
+            result.should be_nil
+          end
+        end
+      end
+    end
+
+    describe "Renew Expired Access Token" do
+      it "should request a new access token when an endpoint returns 401 and client currently has an access_token" do
+        VCR.use_cassette "auth/expired_access_token" do
+          client.access_token.should_not be_empty
+          client.instance_variable_set(:@access_token, "rubbishaccesstoken")
+          response = client.movies.get
+          response.content.should_not be_empty
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'viki'
+require 'vcr'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+
+end

data/spec/support/vcr.rb

@@ -0,0 +1,6 @@
+VCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/vcr_cassettes'
+  c.allow_http_connections_when_no_cassette = true
+  c.hook_into :webmock
+end
+

data/viki.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "viki/version"
+
+Gem::Specification.new do |s|
+  s.name        = "viki"
+  s.version     = Viki::VERSION
+  s.authors     = ["Joost van Amersfoort", "Cedric Chin", "Tommi Lew"]
+  s.email       = ["engineering@viki.com"]
+  s.homepage    = "http://dev.viki.com"
+  s.summary     = "A thin wrapper around the Viki V3 API"
+  s.description = "Viki-gem is an official wrapper gem for the Viki V3 API."
+
+  s.rubyforge_project = "viki"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~> 2.10.0"
+  s.add_development_dependency "vcr", "~> 2.2.2"
+  s.add_development_dependency "webmock", "~> 1.8.7"
+  s.add_development_dependency "excon", "~> 0.9.6"
+  s.add_runtime_dependency     "httparty", "~> 0.8.3"
+  s.add_runtime_dependency     "multi_json", "~> 1.3.6"
+
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: viki
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joost van Amersfoort
+- Cedric Chin
+- Tommi Lew
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70128599563080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *70128599563080
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: &70128599562600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *70128599562600
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70128599562100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *70128599562100
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: &70128599561540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :development
+  prerelease: false
+  version_requirements: *70128599561540
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &70128599560720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70128599560720
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70128599560160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70128599560160
+description: Viki-gem is an official wrapper gem for the Viki V3 API.
+email:
+- engineering@viki.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- lib/viki.rb
+- lib/viki/api_object.rb
+- lib/viki/client.rb
+- lib/viki/error.rb
+- lib/viki/request.rb
+- lib/viki/utilities.rb
+- lib/viki/version.rb
+- spec/client_spec.rb
+- spec/error_spec.rb
+- spec/filter_shared_examples_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
+- spec/support/vcr.rb
+- viki.gemspec
+homepage: http://dev.viki.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: viki
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A thin wrapper around the Viki V3 API
+test_files:
+- spec/client_spec.rb
+- spec/error_spec.rb
+- spec/filter_shared_examples_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
+- spec/support/vcr.rb