yandex_disk 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDJiNmU3ZWM2ZWUwMzVmMzU0NmJmMTBkMzczZjU4NmY1ODk1OGNiYg==
+  data.tar.gz: !binary |-
+    NjE3MjRiM2Y0YzAxNmE2ZGFmNmM0ZGQwZGNhZWRlMTFlMTdhNGJkZA==
+SHA512:
+  metadata.gz: !binary |-
+    OTgyMzRkZDUwYmFlNjMyYzU3ZDIwZmViNWVhZGQ4MzkwNGQ5NDhlNmI5OGY3
+    ZTM1MzRhMzA0YjMxMDJiMjU3MjA1YmJkYTdhMDBmYWQ5NWI2YzBjNGVhMTc2
+    ZDA5NjcyZWRhYjdlODUxMzliYzZjNzdiZDE3YjczYTVjZmNmNWE=
+  data.tar.gz: !binary |-
+    YTg0OTZjMTU1OTBjMDJhYTcwOTNhYWYyMjI0ZWY1ZDliZTBlYjVkMmZkNjFk
+    YjA3Mzk2NWMyZDM2NTM4ZTc3YTNlOWUxNmU3YjRiZTMxOGI2ODkyMzEyOWVl
+    MzkyMjA4NjQxMjJmMTk5M2E0M2Y1Yzk5N2ZjYTU2NjhhOGM4NDU=

data/lib/yandex_disk/api.rb

@@ -0,0 +1,343 @@
+require 'net/http'
+require 'uri'
+require 'zlib'
+require 'base64'
+require 'rexml/document'
+
+require 'yandex_disk/cfg'
+require 'yandex_disk/ext'
+require 'yandex_disk/chunked'
+
+module YandexDisk
+  class RequestError < Exception; end
+
+  class Api
+
+    def initialize(login, pwd)
+      @token = 'Basic ' + Base64.encode64("#{login}:#{pwd}")
+    end
+
+    # TODO gzip file when sending
+    # Example:
+    #   yd.upload('/home/graph.pdf', 'my/work')
+    #   => true
+    #
+    # Arguments:
+    #   file: path to file
+    #   path: path to yandex disk directory (default is <b>root</b>)
+    #   options:
+    #      chunk_size: file chunk size (default is 100)
+    #      force: create path structure if not exist (raise <b>RequestError</b> if <b>path</b> not exist for default)
+    def upload(file, path = '', options = {})
+      # valid file?
+      raise RequestError, "File not found." if file.nil? || !File.file?(file)
+      # create path
+      create_path(path) if options[:force]
+      options[:chunk_size] ||= 100
+      @file = File.open(file)
+      options[:headers] = {'Expect' => '100-continue',
+                           #'Content-Encoding' => 'gzip',
+                           'Transfer-Encoding' => 'chunked',
+                           'content-type' => 'application/binary'}
+
+      send_request(:put, options.merge({:path => File.join( path, File.basename(file) )}))
+      @file.close
+      return true
+    end
+
+    # Example:
+    #   yd.download('/home/graph.pdf', '/home')
+    #   => true
+    #
+    # Arguments:
+    #   file: path to yandex disk file
+    #   save_path: path to save
+    def download(file, save_path)
+      option = {:path => file,
+                :headers => {'TE' => 'chunked',
+                             'Accept-Encoding' => 'gzip'}}
+
+      send_request(:get, option)
+
+      data = nil
+      # unzip if zipped
+      if @response.header['Content-Encoding'] == 'gzip'
+        sio = StringIO.new( @response.body )
+        gz = Zlib::GzipReader.new( sio )
+        data = gz.read
+      else
+        data = @response.body
+      end
+      File.open(File.join(save_path, file.split('/').last), 'w'){|f| f.write(data)}
+
+      return true
+    end
+
+    # Example:
+    #   yd.create_path('/home/my/photos')
+    #   => true
+    #
+    # Arguments:
+    #   path: path to yandex disk directory hierarchy
+    def create_path(path)
+      c_path = ''
+      path.split('/').each do |p|
+        next if p.empty?
+        c_path << p + '/'
+        send_request(:mkcol, {:path => c_path})
+      end
+    end
+    alias_method :mkdir, :create_path
+
+    # Example:
+    #   yd.size
+    #   => {:available => 312312, :used => 3123}
+    def size
+      body = '<?xml version="1.0" encoding="utf-8"?><D:propfind xmlns:D="DAV:"><D:prop><D:quota-available-bytes/><D:quota-used-bytes/></D:prop></D:propfind>'
+      send_propfind(0, {:body => body})
+      xml = REXML::Document.new(@response.body)
+      prop = 'd:multistatus/d:response/d:propstat/d:prop/'
+
+      return {:available => xml.elements[prop + 'd:quota-available-bytes'].text.to_i,
+             :used => xml.elements[prop + 'd:quota-used-bytes'].text.to_i}
+    end
+
+    # Example:
+    #   yd.exist?('/home/graph.pdf')
+    #   => true
+    #
+    # Arguments:
+    #   path: path to yandex disk directory or file
+    def exist?(path)
+      body = '<?xml version="1.0" encoding="utf-8"?><propfind xmlns="DAV:"><prop><displayname/></prop></propfind>'
+      send_propfind(0, {:path => path, :body => body})
+      return true
+    rescue RequestError
+      return false
+    end
+
+    # Example:
+    #   yd.properties('/home/graph.pdf')
+    #   =>
+    #       {:name => 'graph.pdf',
+    #       :created => (Time),
+    #       :updated => (Time),
+    #       :type => 'pdf',
+    #       :size => 42432,
+    #       :is_file => true,
+    #       :public_url => nil}
+    #
+    # Arguments:
+    #   path: path to yandex disk directory or file
+    def properties(path)
+      body = '<?xml version="1.0" encoding="utf-8"?><propfind xmlns="DAV:"><prop><displayname/><creationdate/><getlastmodified/><getcontenttype/><getcontentlength/><public_url xmlns="urn:yandex:disk:meta"/></prop></propfind>'
+      send_propfind(0, {:path => path, :body => body})
+      prop = 'd:multistatus/d:response/d:propstat/d:prop/'
+      xml = REXML::Document.new(@response.body)
+      type = xml.elements[prop + 'd:getcontenttype'].text
+      size = xml.elements[prop + 'd:getcontentlength'].text.to_i
+
+      return {:name => xml.elements[prop + 'd:displayname'].text,
+              :created => xml.elements[prop + 'd:getlastmodified'].text,
+              :updated => xml.elements[prop + 'd:getlastmodified'].text,
+              :type => type ? type : 'dir',
+              :size => size,
+              :is_file => size > 0,
+              :public_url => xml.elements[prop + 'public_url'].text}
+    end
+
+    # Example:
+    #   yd.files('/home')
+    #   =>
+    #       [{:name => 'graph.pdf',
+    #       :created => (Time),
+    #       :updated => (Time),
+    #       :type => 'pdf',
+    #       :size => 42432,
+    #       :is_file => true}]
+    #
+    # Arguments:
+    #   path: path to yandex disk directory (default is <b>root</b>)
+    #   with_root: include information of root directory or not (<b>false</b> for default)
+    def files(path = '', with_root = true)
+      send_propfind(1, {:path => path})
+      xml = REXML::Document.new(@response.body)
+      prop = 'd:propstat/d:prop/'
+      files = []
+      xml.elements.each('d:multistatus/d:response') do |res|
+        name = URI.decode(res.elements[prop + 'd:displayname'].text)
+        next if !with_root && path.split('/').last == name
+        size = res.elements[prop + 'd:getcontentlength'].text.to_i
+
+        files << {:name => name,
+                  :path => URI.decode(res.elements['d:href'].text),
+                  :created => res.elements[prop + 'd:creationdate'].text,
+                  :updated => res.elements[prop + 'd:getlastmodified'].text,
+                  :size => size,
+                  :is_file => size > 0}
+      end
+      return files
+    end
+
+    # Example:
+    #   yd.copy('/home/graph.pdf', 'my/work')
+    #   => true
+    #
+    # Arguments:
+    #   from: path to yandex disk directory or file
+    #   to: path to yandex disk directory
+    def copy(from, to)
+      move_copy(:copy, from, to)
+    end
+    alias_method :cp, :copy
+
+    # Example:
+    #   yd.move('/home/graph.pdf', 'my/work')
+    #   => true
+    #
+    # Arguments:
+    #   from: path to yandex disk directory or file
+    #   to: path to yandex disk directory
+    def move(from, to)
+      move_copy(:move, from, to)
+    end
+    alias_method :mv, :move
+
+    # Example:
+    #   yd.delete('/home/graph.pdf')
+    #   => true
+    #
+    # Arguments:
+    #   path: path to yandex disk directory or file
+    def delete(path)
+      send_request(:delete, {:path => path})
+    end
+    alias_method :del, :delete
+
+    # Example:
+    #   yd.set_public('/home/graph.pdf')
+    #   => http://yadi.sk/d/#############
+    #
+    # Arguments:
+    #   path: path to yandex disk directory or file
+    def set_public(path)
+      body = '<propertyupdate xmlns="DAV:"><set><prop><public_url xmlns="urn:yandex:disk:meta">true</public_url></prop></set></propertyupdate>'
+      send_request(:proppatch, {:path => path, :body => body})
+      xml = REXML::Document.new(@response.body)
+      return xml.elements['d:multistatus/d:response/d:propstat/d:prop/public_url'].text
+    end
+
+    # Example:
+    #   yd.set_private('/home/graph.pdf')
+    #   => true
+    #
+    # Arguments:
+    #   path: path to yandex disk directory or file
+    def set_private(path)
+      body = '<propertyupdate xmlns="DAV:"><remove><prop><public_url xmlns="urn:yandex:disk:meta" /></prop></remove></propertyupdate>'
+      send_request(:proppatch, {:path => path, :body => body})
+      xml = REXML::Document.new(@response.body)
+      return xml.elements['d:multistatus/d:response/d:propstat/d:prop/public_url'].text.nil?
+    end
+
+    # Example:
+    #   yd.preview('/home/cat.jpg', 128, '/home/photo')
+    #   => true
+    #
+    # Arguments:
+    #   path: path to yandex disk file
+    #   size: preview size (for details visit http://api.yandex.com/disk/doc/dg/reference/preview.xml)
+    #   save_to: path to save
+    def preview(path, size, save_to)
+      send_request(:get, {:path => path, :preview => size.to_s})
+      File.open(File.join(save_to, path.split('/').last), 'w'){|f| f.write(@response.body)}
+    end
+
+    ########## private ##########
+    private
+
+    def create_dest(from, to)
+      prop = properties(from)
+      to = prop[:is_file] ? to.gsub(/\/$/,'') + '/' + prop[:name] : to
+      return '/' + to
+    end
+
+    def move_copy(method, from, to)
+      send_request(method, {:path => from,
+                            :headers => {'Destination' => create_dest(from, to)}})
+    end
+
+    def send_propfind(depth, options = {})
+      headers = {:headers => {'Depth' => depth.to_s,
+                              'Content-Type' => 'text/xml; charset="utf-8"'}}
+      send_request(:propfind, options.merge!(headers))
+    end
+
+    def send_request(method, args = {})
+      # headers
+      headers = {'Authorization' => @token}
+      headers.merge!(args[:headers]) if args[:headers]
+      uri = URI.parse(YandexDisk::API_URL)
+      # path
+      path = ''
+      begin
+        unless args[:path].blank?
+          path = URI.encode( args[:path].split('/').reject{|it| it.blank?}.join('/') )
+          raise Exception if path.empty?
+          # image preview
+          path << "?preview&size=#{args[:preview]}" if args[:preview]
+        end
+      rescue Exception => e
+        raise RequestError, 'Path has bad format.'
+      end
+      request_path = uri.request_uri + path
+      # init
+      http = Net::HTTP.new(uri.host, uri.port)
+      # ssl
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      # debug
+      http.set_debug_output($stderr) if YandexDisk::DEBUG
+      # method
+      req = nil
+      case method
+        when :put then
+          req = Net::HTTP::Put.new(request_path, headers)
+          req.body_stream = Chunked.new(@file, args[:chunk_size])
+        when :get then
+          req = Net::HTTP::Get.new(request_path, headers)
+        when :mkcol then
+          req = Net::HTTP::Mkcol.new(request_path, headers)
+        when :propfind then
+          req = Net::HTTP::Propfind.new(request_path, headers)
+        when :copy  then
+          req = Net::HTTP::Copy.new(request_path, headers)
+        when :move  then
+          req = Net::HTTP::Move.new(request_path, headers)
+        when :delete then
+          req = Net::HTTP::Delete.new(request_path, headers)
+        when :proppatch
+          req = Net::HTTP::Proppatch.new(request_path, headers)
+        else
+          raise RequestError, "Method #{method} not supported."
+      end
+      # start
+      req.body = args[:body] if args[:body]
+      http.start{|h| @response = h.request(req) }
+      successful?(method, request_path)
+    end
+
+    def successful?(method, path)
+      if [200, 201, 207].include?(@response.code.to_i)      ||
+         @response.body.include?('resource already exists') ||
+         (method == :delete && @response.body.include?('resource not found'))
+        true
+      else
+        raise RequestError, "#{@response.code.to_i} #{@response.message}: #{@response.body} on #{path}"
+      end
+    end
+  end
+
+end

data/lib/yandex_disk/cfg.rb

@@ -0,0 +1,7 @@
+module YandexDisk
+  VERSION   = '1.0.0'
+  HOME_PAGE = 'https://github.com/denwwer/yandex_disk'
+  API_URL   = 'https://webdav.yandex.ru'
+  # DON'T TURN ON DEBUG FOR PRODUCTION
+  DEBUG = false
+end

data/lib/yandex_disk/chunked.rb

@@ -0,0 +1,23 @@
+# gist from sasimpson
+module YandexDisk
+  class Chunked
+    def initialize(data, chunk_size)
+      @size = chunk_size
+      if data.respond_to? :read
+        @file = data
+      end
+    end
+
+    def read(foo)
+      if @file
+        @file.read(@size)
+      end
+    end
+    def eof!
+      @file.eof!
+    end
+    def eof?
+      @file.eof?
+    end
+  end
+end

data/lib/yandex_disk/ext.rb

@@ -0,0 +1,13 @@
+module YandexDisk
+  class ::String
+    def blank?
+      self.nil? || !self || self.strip.empty?
+    end
+  end
+
+  class ::Object
+    def blank?
+      self.nil? || !self || self.empty?
+    end
+  end
+end

data/lib/yandex_disk.rb

@@ -0,0 +1,13 @@
+module YandexDisk
+  require 'yandex_disk/api'
+
+  class << self
+    def version
+      YandexDisk::VERSION
+    end
+
+    def login(login, pwd)
+      Api.new(login, pwd)
+    end
+  end
+end

data/spec/files/README

@@ -0,0 +1,6 @@
+Files was deleted for decrease gem size.
+Required files for test:
+ sample.txt*
+ sample.jpg
+
+*will be created automatically when run test

data/spec/files/sample.txt

@@ -0,0 +1 @@
+Hi developer.

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+require 'simplecov'
+SimpleCov.start
+require 'rubygems'
+require 'bundler/setup'
+require 'yandex_disk'
+require 'fileutils'
+
+RSpec.configure do |config|
+  config.fail_fast = true
+  config.before(:each) do
+    init_test_files
+  end
+end
+
+# login and password for yandex disk
+LOGIN = ''
+PWD   = ''
+
+# test settings
+FILES_PATH    = File.dirname(__FILE__) + '/files'
+DOWNLOAD_PATH = FILES_PATH + '/downloads'
+FILE_TEXT     = 'Hi developer.'
+
+def init_test_files
+  FileUtils.mkdir_p(DOWNLOAD_PATH) if !Dir.exist?(DOWNLOAD_PATH)
+  @text_file = FILES_PATH + '/sample.txt'
+  File.open(@text_file, 'w+'){|f| f.write(FILE_TEXT)} unless File.file? @text_file
+  @text_file.freeze
+  @image_file = FILES_PATH + '/sample.jpg'
+  @image_file.freeze
+  raise Exception, "File sample.jpg not found in #{FILES_PATH}" unless File.file? @image_file
+end
+
+def clear!
+  @yd.delete('/my').should be_true
+  FileUtils.rm_rf DOWNLOAD_PATH
+end
+

data/spec/yandex_disk_spec.rb

@@ -0,0 +1,180 @@
+#encoding: UTF-8
+require 'spec_helper'
+require 'net/http'
+require 'uri'
+require 'fastimage'
+
+describe YandexDisk do
+
+  it 'should return version' do
+    YandexDisk.version.should equal YandexDisk::VERSION
+  end
+
+  describe 'validate' do
+    it 'authorization' do
+      yd = YandexDisk.login('', '')
+      expect{yd.size}.to raise_error YandexDisk::RequestError
+    end
+
+    it 'file' do
+      yd = YandexDisk.login('', '')
+      expect{yd.upload('not/exist/file')}.to raise_error YandexDisk::RequestError
+    end
+  end
+
+  describe 'api' do
+    before(:each) do
+      @yd = YandexDisk.login(LOGIN, PWD)
+    end
+
+    it 'should return available and used space' do
+      size = @yd.size
+      expect(size[:used] > 0 && size[:available] > 0).to be_true
+    end
+
+    it 'should return list of files' do
+     @yd.files.each do |item|
+        [:name, :path, :created, :updated, :size, :is_file].each{|res| expect(!item[res].to_s.empty?).to be_true}
+     end
+    end
+
+    it 'should return file or dir properties' do
+      # file
+      @yd.upload(@text_file, 'my', {:force => true})
+      properties1 = @yd.properties('my/' + File.basename(@text_file))
+      [:created, :updated, :type, :size, :is_file].each{|res| expect(properties1[res].to_s.empty?).to be_false}
+      properties1[:type].should eq 'text/plain'
+      # dir
+      dir = '/my/photo'
+      @yd.create_path(dir)
+      properties2 = @yd.properties(dir)
+      properties2[:is_file].should be_false
+      clear!
+    end
+
+    describe 'directory' do
+      it 'should be created' do
+        dir = 'my/photos/cats'
+        @yd.create_path(dir).should be_true
+        @yd.properties(dir)[:is_file].should be_false
+      end
+
+      it 'should be copied' do
+        # create directories with Cyrillic name
+        src = 'my/старые файлы'
+        des = 'my/здесь новые файлы'
+
+        @yd.create_path(src)
+        @yd.create_path(des)
+        # create 2 files
+        files = {'file1.txt' => 'data one', 'file2.txt' => 'data two'}
+        files.each do |file, text|
+          new_file = File.join(FILES_PATH, file)
+          File.open(new_file, 'w'){|f| f.write(text)}
+          @yd.upload(new_file, src).should be_true
+        end
+        # copy directory
+        @yd.copy(src, des)
+        # check files
+        @yd.files(src, false).size.should eq 2
+        files.each do |file, text|
+          download_and_validate(File.join(des, file), text)
+        end
+        # clear
+        files.each{|file, text| File.delete( File.join(FILES_PATH, file) )}
+      end
+
+      after(:each) do
+        clear!
+      end
+    end
+
+    describe 'file' do
+      it 'should be uploaded' do
+        @yd.upload(@text_file, 'my', {:force => true}).should be_true
+      end
+
+      it 'should be downloaded and valid' do
+        @yd.upload(@text_file, 'my', {:force => true}).should be_true
+        path = 'my/' + File.basename(@text_file)
+        download_and_validate(path)
+      end
+      # its related to copy dir
+      it 'should by copied to new directory' do
+        @yd.upload(@text_file, 'my', {:force => true})
+        f_name = File.basename(@text_file)
+        file = 'my/' + f_name
+        new_path = 'my/text'
+        @yd.create_path(new_path)
+        @yd.copy(file, new_path)
+        # file still exist in src path
+        @yd.exist?(file).should be_true
+        download_and_validate(File.join(new_path, f_name))
+      end
+
+      it 'should by moved to new directory' do
+        @yd.upload(@text_file, 'my', {:force => true})
+        f_name = File.basename(@text_file)
+        file = 'my/' + f_name
+        new_path = 'my/text'
+        @yd.create_path(new_path)
+        @yd.move(file, new_path)
+        # file not exist in src path
+        @yd.exist?(file).should be_false
+        download_and_validate(File.join(new_path, f_name))
+      end
+
+      it 'should by deleted' do
+        # upload file
+        @yd.upload(@text_file)
+        f_name = File.basename(@text_file)
+        download_and_validate(f_name)
+        @yd.delete(f_name)
+        @yd.exist?(f_name).should be_false
+      end
+
+      it 'should be public'do
+        @yd.upload(@image_file, 'my', {:force => true})
+        # mask: http://yadi.sk/d/#############
+        expect(@yd.set_public('my/' + File.basename(@image_file)) =~ /http:\/\/yadi\.sk\/d\/.+/).to be_true
+      end
+
+      it 'should be private'do
+        @yd.upload(@text_file, 'my', {:force => true})
+        f_name = 'my/' + File.basename(@text_file)
+        # mask: http://yadi.sk/d/#############
+        expect(@yd.set_public(f_name) =~ /http:\/\/yadi\.sk\/d\/.+/).to be_true
+        expect(@yd.set_private(f_name)).to be_true
+      end
+
+      describe 'preview' do
+        before(:each)do
+          @yd.upload(@image_file, 'my', {:force => true}).should be_true
+          @f_name = File.basename(@image_file)
+        end
+
+        it 'should return image in M size'do
+          @yd.preview('my/' + @f_name, 'm', DOWNLOAD_PATH)
+          File.file?( File.join(DOWNLOAD_PATH, @f_name) ).should be_true
+        end
+
+        it 'should return image in 300x250 size'do
+          @yd.preview('my/' + @f_name, '300x250', DOWNLOAD_PATH)
+          FastImage.size( File.join(DOWNLOAD_PATH, @f_name) ).should eq [300, 250]
+        end
+      end
+
+      after(:each) do
+        clear!
+      end
+    end
+
+  end
+
+  def download_and_validate(download_file, text = FILE_TEXT)
+    @yd.download(download_file, DOWNLOAD_PATH).should be_true
+    file = download_file.split('/').last
+    expect( File.read( File.join(DOWNLOAD_PATH, file) ) ).to eq(text)
+  end
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: yandex_disk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Boris Murga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-28 00:00:00.000000000 Z
+dependencies:
+- !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: simplecov
+  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: fastimage
+  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: An easy-to-use client library for Yandex Disk API
+email: denwwer.c4@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yandex_disk.rb
+- lib/yandex_disk/chunked.rb
+- lib/yandex_disk/ext.rb
+- lib/yandex_disk/api.rb
+- lib/yandex_disk/cfg.rb
+- spec/spec_helper.rb
+- spec/files/README
+- spec/files/sample.jpg
+- spec/files/sample.txt
+- spec/yandex_disk_spec.rb
+homepage: https://github.com/denwwer/yandex_disk
+licenses:
+- MIT
+metadata: {}
+post_install_message: Thanks for installation, check https://github.com/denwwer/yandex_disk
+  for news.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: API for Yandex Disk
+test_files:
+- spec/spec_helper.rb
+- spec/files/README
+- spec/files/sample.jpg
+- spec/files/sample.txt
+- spec/yandex_disk_spec.rb