putio-rb 0.0.2

data/lib/putio/client/transfers.rb

@@ -0,0 +1,26 @@
+require 'putio/resource/transfer'
+
+module Putio
+
+  class Client
+
+    module Transfers
+      # Get all the transfers
+      #
+      # @return [Array]
+      def list_transfers
+        resp = get '/transfers/list'
+
+        resp.body.fetch('transfers').inject([]) do |memo, data|
+          memo.push transfer_factory.call(data)
+        end
+      end
+      alias :transfers :list_transfers
+
+      private
+      def transfer_factory
+        @transfer_factory ||= Putio::Resource::Transfer.public_method(:new)
+      end
+    end
+  end
+end

data/lib/putio/configurable.rb

@@ -0,0 +1,44 @@
+module Putio
+
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  module Configurable
+
+    # @!attribute [w] access_token
+    #   @see https://put.io/v2/docs/gettingstarted.html#authentication-and-access
+    #   @return [String] OAuth2 access token for authentication
+    # @!attribute api_endpoint
+    #   @return [URI] Base URL for API requests. default: https://api.put.io/
+    # @!attribute api_version
+    #   @return [String] API version to use. default: v2
+    # @!attribute user_agent
+    #   @return [String] User agent for http requests. default: 'putio-rb ruby client'
+    # @!attribute default_headers
+    #   @return [Hash] Headers to use in http requests.
+    attr_accessor :access_token, :api_endpoint, :api_version, :user_agent, :default_headers
+
+    # List of configurable keys for {Putio::Client}
+    # @return [Array] of option keys
+    def self.keys
+      @keys ||= %i{ access_token api_endpoint api_version user_agent default_headers }
+    end
+
+    # Configure options with a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Putio::Configurable.keys.each do |key|
+        public_send("#{key}=".to_sym, Putio::Defaults.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    def options
+      Hash[Putio::Configurable.keys.map { |key| [key, public_send(key.to_sym)] }]
+    end
+  end
+end

data/lib/putio/connection.rb

@@ -0,0 +1,68 @@
+require 'json'
+require 'uri'
+require 'net/http'
+
+module Putio
+
+  class Connection
+    VERB_MAP = {
+      get:    Net::HTTP::Get,
+      post:   Net::HTTP::Post,
+      put:    Net::HTTP::Put,
+      delete: Net::HTTP::Delete
+    }
+
+    def initialize(endpoint:, headers:{})
+      @endpoint = URI.parse(endpoint)
+      @headers  = headers
+    end
+
+    def request_json(method, path, params)
+      response = request(method, path, params)
+
+      case response.code.to_i
+      when 200 || 201
+        body = JSON.parse(response.body)
+        response_factory.call(code: response.code.to_i, body: body)
+      when (400..499)
+        fail 'bad request'
+      when (500..599)
+        fail 'server problems'
+      end
+    end
+
+    def request(method, path, params)
+      case method
+      when :get
+        full_path = encode_path_params(path, params)
+        request = VERB_MAP[method].new(full_path)
+      else
+        request = VERB_MAP[method].new(path)
+        request.set_form_data(params)
+      end
+
+      http.request(request)
+    end
+
+    private
+    attr_reader :endpoint
+
+    def http
+      @http ||= begin
+        http             = Net::HTTP.new(endpoint.host, endpoint.port)
+        http.use_ssl     = endpoint.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http
+      end
+    end
+
+    def encode_path_params(path, params)
+      encoded = URI.encode_www_form(params)
+      [path, encoded].join('?')
+    end
+
+    def response_factory
+      @response_factory ||= ->(*args) { OpenStruct.new(*args) }
+    end
+  end
+end

data/lib/putio/defaults.rb

@@ -0,0 +1,59 @@
+require 'uri'
+
+module Putio
+
+  # Default configuration options for the client
+  module Defaults
+
+    # Default API endpoint
+    API_ENDPOINT = 'https://api.put.io'
+
+    # Default API version
+    API_VERSION = 'v2'
+
+    # Default User Agent
+    USER_AGENT = 'putio-rb ruby client'
+
+    class << self
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[Putio::Configurable.keys.map { |k| [k, public_send(k)] }]
+      end
+
+      # Default access token from ENV
+      # @return [String]
+      def access_token
+        ENV['PUTIO_ACCESS_TOKEN']
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV.fetch('API_ENDPOINT', API_ENDPOINT)
+      end
+
+      # Default API version from ENV or {API_VERSION}
+      # @return [String]
+      def api_version
+        ENV.fetch('API_VERSION', API_VERSION)
+      end
+
+      # Default User Agent from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV.fetch('USER_AGENT', USER_AGENT)
+      end
+
+      # Default headers for our http requests
+      # @return [Hash]
+      def default_headers
+        {
+          'User-Agent' => "#{user_agent}",
+          'Accept'     => 'application/json'
+        }
+      end
+    end
+  end
+
+end

data/lib/putio/resource/file.rb

@@ -0,0 +1,33 @@
+module Putio
+  module Resource
+    class File
+      VALID_KEYS = %i{ id name content_type is_mp4_available opensubtitles_hash
+        icon created_at parent_id first_accessed_at size screenshot is_shared
+        crc32 }.freeze
+
+      attr_reader *VALID_KEYS
+
+      def initialize(params = {})
+        params.reject! { |k,_| VALID_KEYS.include?(k) }
+        params.map     { |k,v| instance_variable_set("@#{k}", v) }
+      end
+
+      def directory?
+        content_type == 'application/x-directory'
+      end
+
+      def shared?
+        is_shared
+      end
+
+      def mp4_available?
+        is_mp4_available
+      end
+
+      def created_at
+        created_at = super
+        Time.parse(created_at) if created_at
+      end
+    end
+  end
+end

data/lib/putio/resource/transfer.rb

@@ -0,0 +1,11 @@
+module Putio
+  module Resource
+    class Transfer
+      VALID_KEYS = %i{}
+
+      def initialize(params = {})
+
+      end
+    end
+  end
+end

data/lib/putio/version.rb

@@ -0,0 +1,3 @@
+module Putio
+  VERSION = '0.0.2'
+end

data/putio.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'putio/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'putio-rb'
+  s.version       = Putio::VERSION
+  s.date          = '2014-08-07'
+  s.summary       = 'A gem to access put.io api'
+  s.description   = 'putio-rb is a wrapper around put.io api v2 written in ruby.'
+  s.authors       = ['Thibault Gautriaud']
+  s.email         = 'thibault.gautriaud@gmail.com'
+  s.homepage      = 'https://github.com/hubb/putio.rb'
+
+  s.required_ruby_version = '>= 2.0'
+  s.require_paths = ['lib']
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = `git ls-files -- spec/*`.split($/)
+
+  s.add_development_dependency 'bundler'
+end

data/spec/lib/putio/client/files_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe 'Putio::Client Files behaviour' do
+  let(:files)      { File.read('spec/support/files.json') }
+  subject(:client) { Putio::Client.new(access_token: 'foobar') }
+
+  it { expect(client).to respond_to(:list_files) }
+  it { expect(client).to respond_to(:files) }
+
+  describe 'files' do
+    before do
+      stub_request(:get, "https://api.put.io/v2/files/list?oauth_token=foobar&parent_id=0").
+        with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+        to_return(:status => 200, :body => files, :headers => {})
+    end
+
+    it 'should return a collection of Putio::Resource::File' do
+      expect(client.list_files).to be_kind_of(Array)
+      expect(client.list_files.first).to be_kind_of(Putio::Resource::File)
+    end
+
+    context 'when the response is empty' do
+      before do
+        stub_request(:get, "https://api.put.io/v2/files/list?oauth_token=foobar&parent_id=0").
+          with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(:status => 200, :body => "{\"files\":[]}", :headers => {})
+      end
+
+      it 'should return an empty collection' do
+        expect(client.list_files).to be_kind_of(Array)
+        expect(client.list_files).to be_empty
+      end
+    end
+  end
+
+  describe 'search' do
+    before do
+      stub_request(:get, "https://api.put.io/v2/files/search/foobar?oauth_token=foobar").
+        with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+        to_return(:status => 200, :body => files, :headers => {})
+    end
+
+    it 'should return a collection of Putio::Resource::File' do
+      result = client.search(query: 'foobar')
+
+      expect(result).to be_kind_of(Array)
+      expect(result.first).to be_kind_of(Putio::Resource::File)
+    end
+
+    context 'when the response is empty' do
+      before do
+        stub_request(:get, "https://api.put.io/v2/files/search/foobar?oauth_token=foobar").
+          with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(:status => 200, :body => "{\"files\":[]}", :headers => {})
+      end
+
+      it 'should return an empty collection' do
+        result = client.search(query: 'foobar')
+
+        expect(result).to be_kind_of(Array)
+        expect(result).to be_empty
+      end
+    end
+
+    context 'without query' do
+      it { expect { client.search }.to raise_error }
+    end
+
+    context 'with a page' do
+      it 'should query the right page' do
+        mock_request = stub_request(:get, "https://api.put.io/v2/files/search/foobar/page/2?oauth_token=foobar").
+          with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+          to_return(:status => 200, :body => "{\"files\":[]}", :headers => {})
+
+        client.search(query: 'foobar', options: { page: 2 })
+
+        assert_requested(mock_request)
+      end
+    end
+
+    context 'with other search syntax option' do
+      it 'should query with the right options' do
+        mock_request = stub_request(:get, "https://api.put.io/v2/files/search/foobar?ext=mp4&from=me&oauth_token=foobar&time=thisweek&type=video").
+         with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+         to_return(:status => 200, :body => "{\"files\":[]}", :headers => {})
+
+        client.search(query: 'foobar', options: { from: 'me', type: 'video', ext: 'mp4', time: 'thisweek' })
+
+        assert_requested(mock_request)
+      end
+    end
+  end
+
+  describe 'file' do
+    let(:file) { File.read('spec/support/file.json') }
+
+    it 'should query the right endpoint' do
+      mock_request = stub_request(:get, "https://api.put.io/v2/files/123?oauth_token=foobar&parent_id=0").
+         with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+         to_return(:status => 200, :body => "{\"file\":[]}", :headers => {})
+
+      client.file(id: 123)
+
+      assert_requested(mock_request)
+    end
+
+    it 'should return a Putio::Resource::File' do
+      stub_request(:get, "https://api.put.io/v2/files/123?oauth_token=foobar&parent_id=0").
+         with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+         to_return(:status => 200, :body => file, :headers => {})
+
+      expect(client.file(id: 123)).to be_kind_of(Putio::Resource::File)
+    end
+
+    context 'with a parent_id option' do
+      it 'should query with the right option' do
+        mock_request = stub_request(:get, "https://api.put.io/v2/files/123?oauth_token=foobar&parent_id=1234").
+         with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=>'Ruby'}).
+         to_return(:status => 200, :body => "{\"file\":[]}", :headers => {})
+
+        client.file(id: 123, options: { parent_id: 1234 })
+
+        assert_requested(mock_request)
+      end
+    end
+  end
+
+  describe 'delete_files' do
+    before do
+      @mock_request = stub_request(:post, "https://api.put.io/v2/files/delete").
+        with(:body => {"file_ids"=>"1,2,3", "oauth_token"=>"foobar"},
+             :headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/x-www-form-urlencoded', 'User-Agent'=>'Ruby'}).
+        to_return(:status => 200, :body => "{\"status\": \"OK\"}", :headers => {})
+    end
+
+    it { expect(client.delete_files(1,2,3)).to be_truthy }
+
+    it 'should query the right endpoint with options' do
+      client.delete_files(1,2,3)
+
+      assert_requested(@mock_request)
+    end
+  end
+end

data/spec/lib/putio/client_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'putio/client'
+
+describe Putio::Client do
+  let(:access_token) { 'foobar' }
+  subject(:client) { described_class.new(access_token: access_token) }
+
+  it_behaves_like 'a configurable'
+
+  # TODO: extract to files shared examples
+  it { expect(client).to respond_to(:list_files) }
+  # TODO: extract to transfers shared examples
+  it { expect(client).to respond_to(:list_transfers) }
+
+  describe 'inspect' do
+    it { expect(client.inspect).to be_kind_of(String) }
+
+    it 'should hide the access token' do
+      expect(client.inspect).not_to include(access_token)
+      expect(client.inspect).to include('*******')
+    end
+  end
+
+  it { expect(subject).to respond_to(:get) }
+  it { expect(subject).to respond_to(:post) }
+  it { expect(subject).to respond_to(:put) }
+  it { expect(subject).to respond_to(:delete) }
+
+  describe 'request' do
+    let(:connection) { double }
+    before do
+      allow(connection).to receive(:request_json).and_return(true)
+      client.connection = connection
+    end
+
+    it 'should add the access_token to the params' do
+      expect(connection).to receive(:request_json).with(anything, anything, hash_including(:oauth_token))
+      client.get('/foo/bar')
+    end
+
+    it 'should prepend the path with the api version' do
+      expect(connection).to receive(:request_json).with(anything, '/v2/foo/bar', anything)
+      client.get('/foo/bar')
+    end
+
+    %i{ get post put delete }.each do |method|
+      context "when the method is #{method.upcase}" do
+        it "should make a #{method.upcase} request" do
+          expect(connection).to receive(:request_json).with(method, anything, anything)
+          client.public_send(method, '/foo/bar')
+        end
+      end
+    end
+  end
+
+  describe 'connection' do
+    let(:connection) { double(request_json: true) }
+
+    it 'should be initialised with the client endpoint and default_headers' do
+      expect(Putio::Connection).to receive(:new)
+        .with(endpoint: client.api_endpoint, headers: client.default_headers)
+        .and_return(connection)
+
+      client.get('/foo/bar')
+    end
+  end
+end