kuaipan 0.0.3

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gem "json", "1.6.6"
+gem "oauth"
+gem 'rest-client'
+group :test do; end
+

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.6.6)
+    mime-types (1.18)
+    oauth (0.4.5)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json (= 1.6.6)
+  oauth
+  rest-client

data/README.rdoc

@@ -0,0 +1,33 @@
+= kuaipan.gem - the third part SDK of kuaipan@kingsoft.com
+To install the gem simply enter:
+  gem install kuaipan --pre
+To see an example of how it works enter the following into your terminal:
+  git clone git://github.com/tiemei/kuaipan-example.git
+  cd kuaipan-example
+  ruby example.rb
+
+----------- 
+= how to use ?
+  require 'kuaipan'
+  class YourAPI 
+    include Kuaipan::OpenAPI
+    def your_method
+      # 1 config
+      consumer_key = 'YourConsumerKey'
+      consumer_secret = 'YourConsumerSecret'
+      input_config(consumer_key, consumer_secret)
+      
+      # 2 authorize + get_access_token
+      # k_session = g_session() # ok!
+      # k_session = g_session(:oauth_callback => 'Your callbake url') # ok!
+      # authorize_url = k_session[:authorize_url]
+      # user input their username+pwd
+      # then you should parse oauth_verifier
+      k_session.set_atoken oauth_verifier
+      
+      # 3 use Kuaipan API(such as download file, upload file...)
+      # please refer to test/test_client.rb
+      k_session.account_info['user_id'] # get user_id
+    end
+  end
+    

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/kuaipan.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do |s|
+  s.name = 'kuaipan'
+  s.version = '0.0.3'
+  s.date = '2012-05-01'
+  s.summary = "Kuaipan openapi ruby-sdk"
+  s.description = "Kuaipan openAPI! With it , you can develop apps which connect to kuaipan@kingsoft"
+  s.authors = ["tiemei"]
+  s.email = 'jiadongkai@gmail.com'
+  s.files = [
+    "lib/kuaipan.rb", 
+    "lib/kuaipan/base.rb",
+    "lib/kuaipan/config.rb",
+    "lib/kuaipan/session.rb",
+    "lib/kuaipan/errors.rb",
+    "lib/kuaipan/kauth/consumer.rb",
+    "Rakefile",
+    "README.rdoc",
+    "Gemfile",
+    "Gemfile.lock",
+    "kuaipan.gemspec",
+    "test/test_client.rb",
+    "test/kuaipan/test_base.rb",
+    "test/kuaipan/test_config.rb",
+    "test/kuaipan/test_session.rb"
+    ]
+  s.require_paths = ["lib"]
+#s.executables << 'hola_tiemei'
+  s.homepage = 'http://rubygems.org/gems/kuaipan'
+  s.required_ruby_version = '>= 1.9.3'
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_runtime_dependency 'json', '~> 1.6.6'
+  s.add_runtime_dependency 'rest-client'
+
+end

data/lib/kuaipan.rb

@@ -0,0 +1,44 @@
+# conding: utf-8
+require 'forwardable'
+require 'json'
+require 'net/http'
+
+require 'kuaipan/config'
+require 'kuaipan/session'
+require 'kuaipan/base'
+require 'kuaipan/errors'
+
+# kauth-kuaipan oauth implement by myself
+require 'kuaipan/kauth/consumer'
+
+module Kuaipan
+  module OpenAPI
+
+    def input_config(consumer_token, consumer_secret, p={})
+      Kuaipan::Config.opts(consumer_token, consumer_secret, p)
+    end
+
+    def g_session(opt={})
+      Kuaipan::Session.new(opt)
+    end
+    
+    def g_session_skip_oauth(oauth_token, oauth_token_secret, user_id, opts={})
+      Kuaipan::Session.skip_oauth_session(oauth_token, oauth_token_secret, user_id, opts={}) 
+    end
+  end
+
+
+  class InnerLogicalError     < KpErrors; end # 202
+  class BadRequest            < KpErrors; end # 400
+  class Unauthorized          < KpErrors; end # 401
+  class Forbidden             < KpErrors; end # 403
+  class NotFound              < KpErrors; end # 404
+  class NotAcceptable         < KpErrors; end # 406
+  class RequestEntityTooLarge < KpErrors; end # 413
+  class InternalServerError   < KpErrors; end # 500
+  class OverSpace             < KpErrors; end # 507
+  class ServerError           < KpErrors; end # 500..505
+  class UnknownError          < KpErrors; end # other
+  class NoTypeError           < KpErrors; end # documentView no type
+  class NoViewError           < KpErrors; end # documentView no view
+end

data/lib/kuaipan/base.rb

@@ -0,0 +1,132 @@
+# conding: utf-8
+require 'uri'
+module Kuaipan
+  class Base
+    attr_reader :oauth_token
+
+    def initialize(consumer)
+      @consumer = consumer
+    end
+
+    def account_info
+      res =  @consumer.get_no_ssl('account_info')
+      parse_response(res)
+    end
+
+    def metadata(path ,opts={})
+      root = opts[:root] ? opts[:root].to_s : 'app_folder'
+      res = @consumer.get_no_ssl(urlencode("metadata/#{ root }#{ path }"),opts)
+      parse_response(res)
+    end
+
+    def shares(path, opts={})
+      root = opts[:root] ? opts[:root].to_s : 'app_folder'
+      res = @consumer.get_no_ssl(urlencode("shares/#{ root }#{ path }"),opts)
+      parse_response(res)
+    end
+
+    def move(from_path, to_path, opts={})
+      res = @consumer.get_no_ssl('fileops/move',
+                                  {from_path: from_path,
+                                   to_path: to_path,
+                                   root: 'app_folder'}.merge(opts))
+      parse_response(res)
+    end
+    
+    def copy(from_path, to_path, opts={})
+      res = @consumer.get_no_ssl('fileops/copy',
+                                  {from_path: from_path,
+                                   to_path: to_path,
+                                   root: 'app_folder'}.merge(opts))
+      parse_response(res)
+    end
+    
+    def download_file(path, opts={}, &block)
+      res = @consumer.get_no_ssl('fileops/download_file',
+                                  {root: 'app_folder',
+                                   path: path,
+                                   site: Config[:up_down_file_stie]}.merge(opts))
+      parse_response(res, &block)
+    end
+
+    def thumbnail(width, height, path, opts={}, &block)
+      res = @consumer.get_no_ssl('fileops/thumbnail',
+                                  {width: width,
+                                   height: height,
+                                   path: path,
+                                   root: 'app_folder',
+                                   site: Config[:thum_doc_site]}.merge(opts))
+      parse_response(res, &block)
+    end
+    
+
+    def document_view(type, path, opts={},  &block)
+      raise NoTypeError.new("No type:#{ type }") if Config[:types].index(type.to_s) == nil
+      raise NoViewError("No view:#{ opts[:view] }") if (opts[:views] and (Config[:view].index(opts[:view].to_s) == nil))
+      res = @consumer.get_no_ssl('fileops/documentView',
+                                 {view: 'normal',
+                                  zip: 0,
+                                  root: 'app_folder',
+                                  path: path,
+                                  type: type,
+                                  site: Config[:thum_doc_site]
+                                 }.merge(opts))
+      parse_response(res, &block)
+    end
+
+    def upload_locate
+      res = @consumer.get_no_ssl('/fileops/upload_locate', 
+                                  {site: Config[:up_down_file_stie]})
+      parse_response(res)
+    end
+
+
+    def upload_file(file, opts={}) 
+      folder = opts[:path]
+      opts[:path] = opts[:path] ? "/#{ opts[:path] }/#{ File.basename(file.path) }"
+                                : File.basename(file.path)  
+      opts[:root] =  'app_folder' unless opts[:root]
+      create_folder((folder ||= ''), :root => opts[:root])
+      body = @consumer.post('fileops/upload_file', 
+                            file,
+                            {overwrite: 'True', 
+                             site: upload_locate['url'],}.merge(opts))
+      JSON.parse(body)
+    end
+
+    def create_folder(folder, opts={})
+      folder = folder.encode('UTF-8')
+      return nil if folder.size > 255
+      res = @consumer.get_no_ssl('fileops/create_folder', 
+                                  {root: 'app_folder',
+                                   path: folder}.merge(opts))
+      parse_response(res)
+    end
+
+    def delete(path, opts={})
+      res = @consumer.get_no_ssl('fileops/delete', 
+                           {root: 'app_folder',
+                            path: path,
+                            to_recycle: 'True'}.merge(opts))
+      parse_response(res)
+    end
+      
+# .......
+    
+    private 
+      def urlencode(str)
+        URI.escape(str, /([^A-Za-z0-9\-._~])/) 
+      end
+      def parse_response(res, &block)
+        if res.is_a?(Net::HTTPSuccess)
+          if block
+            block.call(res)
+          else
+            JSON.parse(res.body)
+          end
+        else
+          KpErrors.raise_errors(res)
+        end
+      end
+  end
+end

data/lib/kuaipan/config.rb

@@ -0,0 +1,37 @@
+# conding: utf-8
+module Kuaipan
+  module Config
+    class << self
+      extend Forwardable
+      def_delegators :options, :[]
+      attr_accessor :options
+
+      def opts(consumer_key, consumer_secret, p={})
+        Config.options = {oauth_consumer_secret: consumer_secret,
+                          oauth_consumer_key: consumer_key,
+                          root: 'app_folder',
+                          oauth_signature_method: 'HMAC-SHA1',
+                          oauth_version: '1.0',
+                          
+                          site: 'openapi.kuaipan.cn',
+                          thum_doc_site: 'conv.kuaipan.cn',
+                          up_down_file_stie: 'api-content.dfs.kuaipan.cn',
+                          rtoken_path: '/open/requestToken',
+                          atoken_path: '/open/accessToken',
+                          authorize_url: 'https://www.kuaipan.cn/api.php?ac=open&op=authorise',
+                          types: %w(pdf doc wps csv prn xls et ppt dps txt rtf),
+                          views: %w(normal android iPad iphone)
+          }.merge(p)
+      end
+
+      def options_base
+        {oauth_signature_method: Config.options[:oauth_signature_method],
+         oauth_version: Config.options[:oauth_version],
+         oauth_consumer_key: Config.options[:oauth_consumer_key],
+         rtoken_path: Config.options[:rtoken_path],
+         atoken_path: Config.options[:atoken_path],
+         site: Config.options[:site]}
+      end
+    end
+  end
+end

data/lib/kuaipan/errors.rb

@@ -0,0 +1,46 @@
+# conding: utf-8
+module Kuaipan
+  class KpErrors < StandardError
+    def initialize(data)
+      @data = data
+      super
+    end
+
+    def self.raise_errors(res)
+      data = parse(res)
+      case res.code.to_i
+      when 202
+        raise InnerLogicalError.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 400
+        raise BadRequest.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 401
+        raise Unauthorized.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 403
+        raise Forbidden.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 404
+        raise NotFound.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 406
+        raise NotAcceptable.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 413
+        raise RequestEntityTooLarge.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 500
+        raise InternalServerError.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 507
+        raise OverSpace.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      when 500..505
+        raise ServerError.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      else
+        raise UnknownError.new(data['msg']), "(#{ res.code }): #{ res.message } - #{ data['msg'] }"
+      end
+    end
+    
+    private
+      def self.parse(res)
+        if res.body
+          JSON.parse(res.body)
+        else
+          {'msg' => ''}
+        end
+      end
+  end
+end

data/lib/kuaipan/kauth/consumer.rb

@@ -0,0 +1,169 @@
+# coding: utf-8
+require 'json'
+require 'rest_client'
+# std-lib
+require 'base64'
+require 'openssl'
+require 'rest_client'
+require 'net/http'
+
+module KAuth
+  class Consumer
+    attr_accessor :oauth_token, :oauth_token_secret, :user_id
+
+    # determine the certificate authority path to verify SSL certs
+    CA_FILES = %w(/etc/ssl/certs/ca-certificates.crt /usr/share/curl/curl-ca-bundle.crt /etc/ssl/certs/ca-bundle.trust.crt)
+    CA_FILES.each do |ca_file|
+      if File.exists?(ca_file)
+        CA_FILE = ca_file
+        break
+      end
+    end
+    CA_FILE = nil unless defined?(CA_FILE)
+
+    def initialize(ctoken, csecret, opts={})
+      @oauth_consumer_secret = csecret
+      @base_url = opts.delete(:site)
+      @rtoken_path = opts.delete(:rtoken_path)
+      @atoken_path = opts.delete(:atoken_path)
+      @options = {oauth_signature_method: 'HMAC-SHA1',
+                  oauth_version: '1.0',
+                  oauth_consumer_key: ctoken}.merge(opts)
+    end
+
+    def get_request_token(oauth_callback=nil)
+      opts = {}
+      if oauth_callback
+        opts[:oauth_callback] = oauth_callback
+      end
+      res = get('https://', @rtoken_path, opts)
+      body = res.body
+      hash = JSON.parse(body)
+
+      hash.each do |pair|
+        instance_variable_set('@' + pair[0], pair[1])
+      end
+      hash['oauth_token']
+    end
+
+    def set_atoken(oauth_verifier)
+      res = get('https://', 
+                 @atoken_path, 
+                 {oauth_token: @oauth_token,
+                  oauth_verifier: oauth_verifier})
+      body = res.body
+      hash = JSON.parse(body)
+      hash.each do |pair|
+        instance_variable_set("@#{ pair[0] }" , pair[1])
+      end
+    end
+      
+    def get_ssl(path, opts={})
+      opts.merge!({oauth_token: @oauth_token})
+      get('https://', "/#{ @options[:oauth_version].to_i.to_s }/#{ path }", opts)
+    end
+
+    def get_no_ssl(path, opts={})
+      opts.merge!({oauth_token: @oauth_token})
+      get('http://', "/#{ @options[:oauth_version].to_i.to_s }/#{ path }", opts)
+    end
+
+    def post(path, file, opts={})
+      opts.merge!({oauth_token: @oauth_token})
+      base_url_str =  opts[:site] ? opts.delete(:site) : @base_url
+      url = "#{ base_url_str }#{ @options[:oauth_version].to_i.to_s }/#{ path }"
+      params = get_params('POST', url, opts) 
+      uri = URI(url)
+      uri.query = URI.encode_www_form(params)
+      RestClient.post(uri.to_s, :my_file => file)
+    end
+
+
+    private 
+      def get_params(http_method, url, opts={})
+        params = {oauth_nonce: Consumer.get_oauth_nonce,
+                  oauth_timestamp: "#{Time.new.to_i}"
+                 }.merge(@options).merge(opts)
+        params[:oauth_signature] = get_oath_signature(Consumer.get_base_string(params, url, http_method))
+        params
+      end
+
+      def self.get_oauth_nonce
+        a = [(1..9),('a'..'z'),('A'..'Z')].map{|r|r.to_a}.flatten 
+        a << '_'
+        (1...32).map{a[rand(a.size)]}.join
+      end
+
+      # 生成签名算法
+      def get_oath_signature(base_str)
+        key = @oauth_consumer_secret + '&'
+        key += @oauth_token_secret if base_str.include?('oauth_token')
+        Base64.encode64("#{OpenSSL::HMAC.digest('sha1', key, base_str)}").chomp
+      end
+
+      def get(pre, path, opts={})
+        base_url_str =  opts[:site] ? opts.delete(:site) : @base_url
+        url = "#{ pre }#{ base_url_str }#{ path }"
+        params = get_params('GET', url, opts)
+        fetch(url, params)
+#fetch(url, 'GET', opts)
+      end
+
+      def fetch(url, params, limit=10)
+#params = get_params(http_method, url, opts)
+        raise TooManyRedirect, 'too many redirect!' if limit == 0
+        
+        uri = URI(url)
+        uri.query = URI.encode_www_form(params)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.ca_file = CA_FILE
+        request = Net::HTTP::Get.new(uri.request_uri)
+        
+        response = http.request(request)
+        case response
+        when Net::HTTPRedirection
+          location = response['location']
+          uri = URI(location)
+          req = Net::HTTP::Get.new(uri.request_uri)
+          req['Cookie'] = response['set-cookie']
+          res = Net::HTTP.start(uri.hostname, uri.port) {|http|
+              http.request(req)
+          }
+#response = Net::HTTP.get_response(uri, {'Cookie' => response['set-cookie']})
+#fetch(location, cookie)
+#fetch(location, http_method, opts, limit - 1)
+        else
+          response
+        end  
+      end
+
+      def self.get_base_string(params, url, http_method)
+        param_str_arr = []
+        params.sort.each do |pair|
+          param_str_arr << "#{ urlencode(pair[0].to_s) }=#{ urlencode(pair[1].to_s) }"  
+        end
+        "#{http_method}&#{urlencode url}&#{urlencode param_str_arr.join('&')}"
+      end
+
+      def self.urlencode(str)
+        # 下面两种方式均可
+        #str.gsub(/([^A-Za-z0-9\-._~])/)do |s|
+          #a = []
+          #s.bytes.to_a.each{|i|  a << ("%%%02X" % i)}
+          #a.join
+        #end
+        URI.escape(str, /([^A-Za-z0-9\-._~])/)
+      end
+      
+  end
+
+  class KAuthError < StandardError
+    attr_reader :res
+    def initialize(res)
+      @res = res
+      super
+    end
+  end
+  class TooManyRedirect < StandardError; end
+end

data/lib/kuaipan/session.rb

@@ -0,0 +1,54 @@
+# conding: utf-8
+module Kuaipan
+  class Session
+    extend Forwardable
+    attr_reader :authorize_url,:base, :consumer
+    def_delegators :base, :account_info, :upload_file, 
+                   :create_folder, :delete, :metadata, 
+                   :copy, :download_file, :thumbnail, 
+                   :shares, :move, :document_view
+    def_delegators :authorize_url, :[]
+    
+    def initialize(opt={})
+      oauth_callback = opt.delete(:oauth_callback)
+      @consumer = KAuth::Consumer.new(Config[:oauth_consumer_key], 
+                                      Config[:oauth_consumer_secret], 
+                                      Config.options_base)
+      # get rtoken
+      begin
+        rtoken = @consumer.get_request_token(oauth_callback)
+        @base = Base.new(@consumer)
+        # set authorize_url
+        @authorize_url = {authorize_url: "#{ Config[:authorize_url] }&oauth_token=#{ rtoken }"}
+      rescue KAuth::KAuthError => myKauthError
+        KpErrors.raise_errors(myKauthError.res)
+      end
+    end
+
+    def set_atoken(oauth_verifier)
+      # set accesstoken
+      begin
+        @consumer.set_atoken(oauth_verifier)
+        {oauth_token: @consumer.oauth_token,
+         oauth_token_secret: @consumer.oauth_token_secret,
+         user_id: @consumer.user_id}
+      rescue KAuth::KAuthError => myKauthError
+        KpErrors.raise_errors(myKauthError.res)
+      end
+    end
+    
+    def get_oauth_result
+      {oauth_token: @consumer.oauth_token,
+       oauth_token_secret: @consumer.oauth_token_secret,
+       user_id: @consumer.user_id}
+    end
+    
+    def self.skip_oauth_session(oauth_token, oauth_token_secret, user_id, opts={})
+      session = Session.new(opts)
+      session.consumer.oauth_token = oauth_token
+      session.consumer.oauth_token_secret = oauth_token_secret
+      session.consumer.user_id = user_id
+      session
+    end
+  end
+end

data/test/kuaipan/test_base.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'kuaipan'
+
+class BaseTest < Test::Unit::TestCase
+  def test_usr_info
+    #File.open("../../usr.json", 'r'){ |f|
+     #json = f.read
+     #hash = JSON.parse json
+     #hash.each do |pair|
+       #instance_variable_set pair[0], pair[1]
+     #end
+    #consumer =   
+    #base = Kuaipan::Base.new consumer
+    #base.usr_info['user_id']
+  end
+end

data/test/kuaipan/test_config.rb

@@ -0,0 +1,12 @@
+require 'kuaipan'
+require 'test/unit'
+
+class ConfigTest < Test::Unit::TestCase
+  def test_attrs
+    ckey,csecret,p = '123', '321!', {:root => 'kuaipan'}
+    Kuaipan::Config.opts ckey, csecret, p
+    assert_equal csecret, Kuaipan::Config[:oauth_consumer_secret]
+    assert_equal ckey, Kuaipan::Config[:oauth_consumer_key]
+    assert_equal 'kuaipan', Kuaipan::Config[:root]
+  end
+end

data/test/kuaipan/test_session.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'kuaipan'
+
+class SessionTest < Test::Unit::TestCase
+  def test_initialize
+
+  end
+
+  def test_set_atoken
+
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,99 @@
+# conding: utf-8
+require 'kuaipan'
+require 'test/unit'
+
+class ClientTest < Test::Unit::TestCase
+  include Kuaipan::OpenAPI
+
+  def test_open_api
+    ct, cs = 'xcWcZhCNKFJz1H8p', '8RvkM0aGYiQF5kJF'
+    input_config ct, cs
+    k_session = nil
+    oauth_result_file = 'oauth_result.json'
+    if File.exist?(oauth_result_file)
+      File.open(oauth_result_file, 'r')do |f|
+        oauth_result = JSON.parse(f.read)
+        k_session = g_session_skip_oauth(oauth_result['oauth_token'],
+                                         oauth_result['oauth_token_secret'],
+                                         oauth_result['user_id'])
+      end
+    else
+      k_session = g_session 
+      authorize_url = k_session[:authorize_url]
+      p 'please input this url to your browser,then copy authorization code here:'
+      p authorize_url
+      oauth_verifier = gets
+      oauth_result = k_session.set_atoken oauth_verifier
+      File.open(oauth_result_file,'w+')do |f|
+        f.write(JSON.generate(oauth_result))
+      end
+    end
+    
+
+    # get account info
+    assert_not_nil k_session.account_info['user_id']
+
+    # 1 create folder
+    # 2 get metadata of folder
+    # 3 create repeated folder 
+    # 4 delete folder
+    folder = '/tiemei_kuaipan_test/test'
+    begin
+      assert_equal 'ok', k_session.create_folder(folder)['msg']
+      assert_not_nil k_session.metadata('/tiemei_kuaipan_test')['root']
+      assert_equal 'ok', k_session.create_folder(folder)['msg']
+    ensure
+      k_session.delete('/tiemei_kuaipan_test')
+    end
+
+
+    # upload one file to a folder
+    # delete folder
+    # download file
+    # delete file
+    folder = 'kuaipan_testfolder'
+    file_name = '.kuaipan_test_file_123'
+    rename = 'renameFile'
+    copyname = 'copyfil.txt'
+    dir = 'demo_tiemei'
+    file = File.open("#{ file_name }",'w+b')do |f|
+      f.write('test content!You can delete it')
+      f.flush
+    end
+    file = File.open("#{ file_name }", 'rb')
+    begin 
+      assert_not_nil k_session.upload_file(file, {:path => "/#{ folder }"})['file_id']
+      p k_session.shares("/#{ folder }/#{ file_name }").to_s
+      k_session.move("/#{ folder }/#{ file_name }", 
+                     "/#{ folder }/#{ rename }")
+      assert_not_nil k_session.copy("/#{ folder }/#{ rename }", 
+                                    "/#{ folder }/#{ copyname }")['file_id']
+      k_session.download_file("/#{ folder }/#{ copyname }")do |res|
+        Dir.mkdir(dir) unless Dir.exist?(dir)
+        file = File.open("#{ dir }/#{ copyname }", 'wb')do |f|
+          f.write(res.body)
+          f.flush
+        end
+      end
+      # document_view
+      k_session.document_view('txt', "#{ folder }/#{ copyname }")do |res|
+        p res.body
+      end
+        
+    ensure
+      k_session.delete(folder)
+      File.delete(file)
+    end
+
+    # get thumbnail
+    k_session.thumbnail(100, 100, '08.jpg')do |res|
+      Dir.mkdir(dir) unless Dir.exist?(dir)
+      file = File.open("#{ dir }/#{ '08.jpg' }", 'wb')do |f|
+        f.write(res.body)
+        f.flush
+      end
+    end
+
+
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: kuaipan
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- tiemei
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.6
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Kuaipan openAPI! With it , you can develop apps which connect to kuaipan@kingsoft
+email: jiadongkai@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kuaipan.rb
+- lib/kuaipan/base.rb
+- lib/kuaipan/config.rb
+- lib/kuaipan/session.rb
+- lib/kuaipan/errors.rb
+- lib/kuaipan/kauth/consumer.rb
+- Rakefile
+- README.rdoc
+- Gemfile
+- Gemfile.lock
+- kuaipan.gemspec
+- test/test_client.rb
+- test/kuaipan/test_base.rb
+- test/kuaipan/test_config.rb
+- test/kuaipan/test_session.rb
+homepage: http://rubygems.org/gems/kuaipan
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Kuaipan openapi ruby-sdk
+test_files: []