Merge pull request #9 from why404/master

新增服务端上传方法 Qiniu::RS.put_file()，并完美通过所有39个单元测试

.gitignore

@@ -5,7 +5,6 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage

Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    qiniu-rs (2.3.0)
+      json (~> 1.7.3)
+      mime-types (~> 1.19)
+      rest-client (~> 1.6.7)
+      ruby-hmac (~> 0.4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    fakeweb (1.3.0)
+    json (1.7.3)
+    mime-types (1.19)
+    rake (0.9.2.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    ruby-hmac (0.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakeweb (~> 1.3.0)
+  qiniu-rs!
+  rake (~> 0.9.2.2)
+  rspec (~> 2.10.0)

README.md

@@ -1,8 +1,8 @@
-# Qiniu Resource (Cloud) Storage SDK for Ruby - [![Build Status](https://secure.travis-ci.org/why404/qiniu-rs.png?branch=master)](http://travis-ci.org/why404/qiniu-rs) [![Dependency Status](https://gemnasium.com/why404/qiniu-rs.png)](https://gemnasium.com/why404/qiniu-rs)
+# Qiniu Resource (Cloud) Storage SDK for Ruby - [![Build Status](https://secure.travis-ci.org/why404/qiniu-rs-for-ruby.png?branch=master)](http://travis-ci.org/why404/qiniu-rs-for-ruby) [![Dependency Status](https://gemnasium.com/why404/qiniu-rs-for-ruby.png)](https://gemnasium.com/why404/qiniu-rs-for-ruby)
 
 # 关于
 
-此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x 版本，基于 [七牛云存储官方API](http://docs.qiniutek.com/v1/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
+此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](http://docs.qiniutek.com/v2/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
 
 ## 安装
 
@@ -20,7 +20,7 @@
 
 ## 使用
 
-参考文档：[七牛云存储 Ruby SDK 使用指南](http://docs.qiniutek.com/v1/sdk/ruby/)
+参考文档：[七牛云存储 Ruby SDK 使用指南](http://docs.qiniutek.com/v2/sdk/ruby/)
 
 ## 贡献代码
 
@@ -32,7 +32,7 @@
 
 ## 许可证
 
-Copyright (c) 2012 why404
+Copyright (c) 2012 qiniutek.com
 
 基于 MIT 协议发布:
 

docs/README.md

@@ -0,0 +1,637 @@
+---
+title: Ruby SDK 使用指南 | 七牛云存储
+---
+
+# Ruby SDK 使用指南
+
+此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](/v2/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
+
+七牛云存储 Ruby SDK 源码地址：[https://github.com/qiniu/ruby-sdk](https://github.com/qiniu/ruby-sdk)
+
+**文档大纲**
+
+- [安装](#Installation)
+- [使用](#Usage)
+    - [应用接入](#establish_connection!)
+    - [Ruby On Rails 应用初始化设置](#ror-init)
+    - [上传文件](#upload)
+        - [服务端上传流程](#upload-server-side)
+        - [客户端上传流程](#upload-client-side)
+            - [获取用于上传文件的临时授权URL](#put_auth)
+    - [查看文件属性信息](#stat)
+    - [获取文件下载链接（含文件属性信息）](#get)
+    - [只获取文件下载链接](#download)
+    - [删除指定文件](#delete)
+    - [删除所有文件（单个“表”）](#drop)
+    - [批量操作](#batch)
+        - [批量获取文件属性信息（含下载链接）](#batch_get)
+        - [批量获取文件下载链接](#batch_download)
+        - [批量删除文件](#batch_delete)
+    - [创建公开外链](#publish)
+    - [取消公开外链](#unpublish)
+    - [图像处理](#op-image)
+        - [查看图片属性信息](#image_info)
+        - [获取指定规格的缩略图预览地址](#image_preview_url)
+        - [高级图像处理（缩略、裁剪、旋转、转化）](#image_mogrify_preview_url)
+        - [高级图像处理（缩略、裁剪、旋转、转化）并持久化](#image_mogrify_save_as)
+
+- [贡献代码](#Contributing)
+- [许可证](#License)
+
+<a name="Installation"></a>
+
+## 安装
+
+<a name="Usage"></a>
+
+在您 Ruby 应用程序的 `Gemfile` 文件中，添加如下一行代码：
+
+    gem 'qiniu-rs'
+
+然后，在应用程序所在的目录下，可以运行 `bundle` 安装依赖包：
+
+    $ bundle
+
+或者，可以使用 Ruby 的包管理器 `gem` 进行安装：
+
+    $ gem install qiniu-rs
+
+
+## 使用
+
+<a name="establish_connection!"></a>
+
+### 应用接入
+
+要接入七牛云存储，您需要拥有一对有效的 Access Key 和 Secret Key 用来进行签名认证。可以通过如下步骤获得：
+
+1. [开通七牛开发者帐号](https://dev.qiniutek.com/signup)
+2. [登录七牛开发者自助平台，查看 Access Key 和 Secret Key](https://dev.qiniutek.com/account/keys) 。
+
+在获取到 Access Key 和 Secret Key 之后，您可以在您的程序中调用如下两行代码进行初始化对接：
+
+    Qiniu::RS.establish_connection! :access_key => YOUR_APP_ACCESS_KEY,
+                                    :secret_key => YOUR_APP_SECRET_KEY
+
+<a name="ror-init"></a>
+
+### Ruby On Rails 应用初始化设置
+
+如果您使用的是 [Ruby on Rails](http://rubyonrails.org/) 框架，我们建议您在应用初始化启动的过程中，依次调用上述两个函数即可，操作如下：
+
+首先，在应用初始化脚本加载的目录中新建一个文件：`YOUR_RAILS_APP/config/initializers/qiniu-rs.rb`
+
+然后，编辑 `YOUR_RAILS_APP/config/initializers/qiniu-rs.rb` 文件内容如下：
+
+    Qiniu::RS.establish_connection! :access_key => YOUR_APP_ACCESS_KEY,
+                                    :secret_key => YOUR_APP_SECRET_KEY
+
+这样，您就可以在您的 `RAILS_APP` 中使用七牛云存储 Ruby SDK 提供的其他任意方法了。
+
+接下来，我们会逐一介绍此 SDK 提供的其他方法。
+
+<a name="upload"></a>
+
+### 上传文件
+
+<a name="upload-server-side"></a>
+
+#### 服务端上传流程
+
+通过 `Qiniu::RS.put_file()` 方法可在客户方的业务服务器上直接往七牛云存储上传文件。该函数规格如下：
+
+    Qiniu::RS.put_file :file               => file_path,
+                       :key                => record_id,
+                       :bucket             => bucket_name,
+                       :mime_type          => file_mime_type,
+                       :note               => some_notes,
+                       :enable_crc32_check => true
+
+**参数**
+
+:file
+: 必须，字符串类型（String），本地文件可被读取的有效路径
+
+:bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，指定将该数据属性信息存储到具体的资源表中 。
+
+:key
+: 必须，字符串类型（String），类似传统数据库里边某个表的主键ID，给每一个文件一个UUID用于进行标示。
+
+:mime_type
+: 可选，字符串类型（String），文件的 mime-type 值。如若不传入，SDK 会自行计算得出，若计算失败缺省使用 application/octet-stream 代替之。
+
+:note
+: 可选，字符串类型（String），备注信息。
+
+:enable_crc32_check
+: 可选，Boolean 类型，是否启用文件上传 crc32 校验，默认为 false 。
+
+**返回值**
+
+上传成功，返回 `true`，否则返回 `false` 。
+
+**针对 NotFound 处理**
+
+您可以上传一个应对 HTTP 404 出错处理的文件，当您 [创建公开外链](#publish) 后，若公开的外链找不到该文件，即可使用您上传的“自定义404文件”代替之。要这么做，您只须使用 `Qiniu::RS.put_file` 函数上传一个 `key` 为固定字符串类型的值 `errno-404` 即可。
+
+<a name="upload-client-side"></a>
+
+#### 客户端上传流程
+
+<a name="put_auth"></a>
+
+#### 获取用于上传文件的临时授权URL
+
+    Qiniu::RS.put_auth(expires_in = nil, callback_url = nil)
+
+要上传一个文件，首先需要调用 SDK 提供的 `Qiniu::RS.put_auth` 函数来获取一个经过授权用于临时匿名上传的 URL 。 “临时” 一词表示该 URL 有一定的时效性，即过一段时间后会过期，有效期由传入的参数 `expires_in` 决定，缺省情况下 `expires_in` 的值是 3600 秒，即 1 小时后该上传链接不再有效（但该上传URL在其生成之后的59分59秒都是可用的）。
+
+**参数**
+
+expires_in
+: 可选，整型，用于设置上传 URL 的有效期，单位：秒，缺省为 3600 秒
+
+callback_url
+: 可选，字符串类型（String），用于设置文件往这个 URL 上传成功后，七牛云存储服务端要回调客户方的业务服务器地址。
+
+**返回值**
+
+如果请求成功，返回一个字符串类型（String）的用于上传文件的已授权的临时有效 URL ，否则返回 `false` 。
+
+**示例**
+
+    remote_upload_url = Qiniu::RS.put_auth(60, 'http://api.example.com/notifications/qiniu-rs')
+
+如果您的网络程序是从云端（服务端程序）到终端（手持设备应用）的架构模型，且终端用户有使用您移动端App上传文件（比如照片或视频）的需求，可以把您服务器得到的此 `remote_upload_url` 返回给手持设备端的App，然后您的移动 App 可以使用 [七牛云存储 Objective-SDK （iOS）](http://docs.qiniutek.com/v2/sdk/objc/) 或 [七牛云存储 Java-SDK（Android）](http://docs.qiniutek.com/v2/sdk/java/) 的相关上传函数或参照 [七牛云存储API之文件上传](http://docs.qiniutek.com/v2/api/io/#rs-PutFile) 往该 `remote_upload_url` 上传文件。这样，您的终端用户即可把数据（比如图片或视频）直接上传到七牛云存储服务器上无须经由您的服务端中转，而且在上传之前，七牛云存储做了智能加速，终端用户上传数据始终是离他物理距离最近的存储节点。当终端用户上传成功后，七牛云存储服务端会向您指定的 `callback_url` 发送回调数据。在此示例程序中，七牛云存储服务端会将一组关于终端用户上传的数据的属性信息通过 HTTP POST 以 `application/x-www-form-urlencoded` 编码的方式发送到 `http://api.example.com/notifications/qiniu-rs` 这个地址，假设该地址是您业务服务器用于接收处理回调信息的地址。
+
+
+<a name="stat"></a>
+
+### 查看文件属性信息
+
+    Qiniu::RS.stat(bucket, key)
+
+可以通过 SDK 提供的 `Qiniu::RS.stat` 函数，来查看某个已上传文件的属性信息。
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+key
+: 必须，字符串类型（String），类似传统数据库里边某个表的主键ID，每一个文件最终都用一个唯一 `key` 进行标示。
+
+**返回值**
+
+如果请求失败，返回 `false`；否则返回如下一个 `Hash` 类型的结构：
+
+    {
+        "fsize"    => 3053,
+        "hash"     => "Fu9lBSwQKbWNlBLActdx8-toAajv",
+        "mimeType" => "application/x-ruby",
+        "putTime"  => 13372775859344500
+    }
+
+fsize
+: 表示文件总大小，单位是 Byte
+
+hash
+: 文件的特征值，可以看做是基版本号
+
+mimeType
+: 文件的 mime-type
+
+putTime
+: 上传时间，单位是 百纳秒
+
+<a name="get"></a>
+
+### 获取文件下载链接（含文件属性信息）
+
+    Qiniu::RS.get(bucket, key, save_as = nil, expires_in = nil, version = nil)
+
+`Qiniu::RS.get` 函数除了能像 `Qiniu::RS.stat` 一样返回文件的属性信息外，还能返回具体的下载链接及其有效时间。
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+key
+: 必须，字符串类型（String），类似传统数据库里边某个表的主键ID，每一个文件最终都用一个唯一 `key` 进行标示。
+
+save_as
+: 可选，字符串类型（String），文件下载时保存的具体名称
+
+expires_in
+: 可选，整型，用于设置下载 URL 的有效期，单位：秒，缺省为 3600 秒
+
+version
+: 可选，字符串类型（String），值为 `Qiniu::RS.stat` 或 `Qiniu::RS.get` 函数返回的 `hash` 字段的值，可用于断点续下载。
+
+**返回值**
+
+如果请求失败，返回 `false`；否则返回如下一个 `Hash` 类型的结构：
+
+    {
+        "fsize"    => 3053,
+        "hash"     => "Fu9lBSwQKbWNlBLActdx8-toAajv",
+        "mimeType" => "application/x-ruby",
+        "url"      => "http://iovip.qbox.me/file/<an-authorized-token>",
+        "expires"  => 3600
+    }
+
+fsize
+: 表示文件总大小，单位是 Byte
+
+hash
+: 文件的特征值，可以看做是基版本号
+
+mimeType
+: 文件的 mime-type
+
+url
+: 文件的临时有效下载链接
+
+expires
+: 文件下载链接的有效期，单位为 秒，过了 `expires` 秒之后，下载 `url` 将不再有效
+
+<a name="download"></a>
+
+### 只获取文件下载链接
+
+    Qiniu::RS.download(bucket, key, save_as = nil, expires_in = nil, version = nil)
+
+`Qiniu::RS.download` 函数参数与 `Qiniu::RS.get` 一样，差别在于，`Qiniu::RS.download` 只返回文件的下载链接。
+
+<a name="delete"></a>
+
+### 删除指定文件
+
+    Qiniu::RS.delete(bucket, key)
+
+`Qiniu::RS.delete` 函数提供了从指定的 `bucket` 中删除指定的 `key`，即删除 `key` 索引关联的具体文件。
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+key
+: 必须，字符串类型（String），类似传统数据库里边某个表的主键ID，每一个文件最终都用一个唯一 `key` 进行标示。
+
+**返回值**
+
+如果删除成功，返回 `true`，否则返回 `false` 。
+
+<a name="drop"></a>
+
+### 删除所有文件（单个“表”）
+
+    Qiniu::RS.drop(bucket)
+
+`Qiniu::RS.drop` 提供了删除整个 `bucket` 及其里边的所有 `key`，以及这些 `key` 关联的所有文件都将被删除。
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+**返回值**
+
+如果删除成功，返回 `true`，否则返回 `false` 。
+
+<a name="batch"></a>
+
+### 批量操作
+
+    Qiniu::RS.batch(command, bucket, keys)
+
+SDK 还提供了 `Qiniu::RS.batch` 函数来提供批量处理 `Qiniu::RS.stat` 或是 `Qiniu::RS.get` 或 `Qiniu::RS.delete` 的相应功能。
+
+**参数**
+
+command
+: 必须，字符串类型（String），其值可以是 `stat`, `get`, `delete` 中的一种
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+keys
+: 必须，数组类型（Array），所要操作 `key` 的集合。
+
+**返回值**
+
+如果请求失败，返回 `false`，否则返回一个 `Array` 类型的结构，其中每个元素是一个 `Hash` 类型的结构。例如批量`get`：
+
+    [
+        {
+            "code" => 200,
+            "data" => {
+                "expires"  => 3600,
+                "fsize"    => 3053,
+                "hash"     => "Fu9lBSwQKbWNlBLActdx8-toAajv",
+                "mimeType" => "application/x-ruby",
+                "url"      => "http://iovip.qbox.me/file/<an-authorized-token>"
+            }
+        },
+        ...
+    ]
+
+<a name="batch_get"></a>
+
+#### 批量获取文件属性信息（含下载链接）
+
+    Qiniu::RS.batch_get(bucket, keys)
+
+`Qiniu::RS.batch_get` 函数是在 `Qiniu::RS.batch` 之上的封装，提供批量获取文件属性信息（含下载链接）的功能。
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，每份数据是属性信息都存储到具体的 bucket（资源表）中 。
+
+keys
+: 必须，数组类型（Array），所要操作 `key` 的集合。
+
+**返回值**
+
+如果请求失败，返回 `false`，否则返回一个 `Array` 类型的结构，其中每个元素是一个 `Hash` 类型的结构。`Hash` 类型的值同 `Qiniu::RS.get` 函数的返回值类似，只多出一个 `code` 字段，`code` 为 200 表示所有 keys 全部获取成功，`code` 若为 298 表示部分获取成功。
+
+    [
+        {
+            "code" => 200,
+            "data" => {
+                "expires"  => 3600,
+                "fsize"    => 3053,
+                "hash"     => "Fu9lBSwQKbWNlBLActdx8-toAajv",
+                "mimeType" => "application/x-ruby",
+                "url"      => "http://iovip.qbox.me/file/<an-authorized-token>"
+            }
+        },
+        ...
+    ]
+
+<a name="batch_download"></a>
+
+#### 批量获取文件下载链接
+
+    Qiniu::RS.batch_download(bucket, keys)
+
+`Qiniu::RS.batch_download` 函数也是在 `Qiniu::RS.batch` 之上的封装，提供批量获取文件下载链接的功能。
+
+参数同 `Qiniu::RS.batch_get` 的参数一样。
+
+**返回值**
+
+如果请求失败，返回 `false`，否则返回一个 `Array` 类型的结构，其中每个元素是一个字符串类型的下载链接：
+
+    ["<download-link-1>", "<download-link-2>", …, "<download-link-N>"]
+
+<a name="batch_delete"></a>
+
+#### 批量删除文件
+
+    Qiniu::RS.batch_delete(bucket, keys)
+
+`Qiniu::RS.batch_download` 函数也是在 `Qiniu::RS.batch` 之上的封装，提供批量删除文件的功能。
+
+参数同 `Qiniu::RS.batch_get` 的参数一样。
+
+**返回值**
+
+如果批量删除成功，返回 `true` ，否则为 `false` 。
+
+<a name="publish"></a>
+
+### 创建公开外链
+
+    Qiniu::RS.publish(domain, bucket)
+
+调用 `Qiniu::RS.publish` 函数可以将您在七牛云存储中的资源表 `bucket` 发布到某个 `domain` 下，`domain` 需要在 DNS 管理里边 CNAME 到 `iovip.qbox.me` 。
+
+这样，用户就可以通过 `http://<domain>/<key>` 来访问资源表 `bucket` 中的文件。键值为 `foo/bar/file` 的文件对应访问 URL 为 `http://<domain>/foo/bar/file`。 另外，`domain` 可以是一个真实的域名，比如 `www.example.com`，也可以是七牛云存储的二级路径，比如 `io.qbox.me/example` 。
+
+例如：执行 `Qiniu::RS.publish("cdn.example.com", "EXAMPLE_BUCKET")` 后，那么键名为 `foo/bar/file` 的文件可以通过 `http://cdn.example.com/foo/bar/file` 访问。
+
+**参数**
+
+domain
+: 必须，字符串类型（String），资源表发布的目标域名，例如：`cdn.example.com`
+
+bucket
+: 必须，字符串类型（String），要公开发布的资源表名称。
+
+**返回值**
+
+如果发布成功，返回 `true`，否则返回 `false` 。
+
+<a name="unpublish"></a>
+
+### 取消公开外链
+
+    Qiniu::RS.unpublish(domain)
+
+可以通过 SDK 提供的 `Qiniu::RS.unpublish` 函数来取消指定 `bucket` 的在某个 `domain` 域下的所有公开外链访问。
+
+**参数**
+
+domain
+: 必须，字符串类型（String），资源表已发布的目标域名名称，例如：`cdn.example.com`
+
+**返回值**
+
+如果撤销成功，返回 `true`，否则返回 `false` 。
+
+<a name="op-image"></a>
+
+### 图像处理
+
+<a name="image_info"></a>
+
+#### 查看图片属性信息
+
+    Qiniu::RS.image_info(url)
+
+使用 SDK 提供的 `Qiniu::RS.image_info` 方法，可以基于一张存储于七牛云存储服务器上的图片，针对其下载链接来获取该张图片的属性信息。
+
+**参数**
+
+url
+: 必须，字符串类型（String），图片的下载链接，需是 `Qiniu::RS.get`（或`Qiniu::RS.batch_get`）函数返回值中 `url` 字段的值，或者是 `Qiniu::RS.download`（或`Qiniu::RS.batch_download`）函数返回的下载链接。且文件本身必须是图片。
+
+**返回值**
+
+如果请求失败，返回 `false`；否则，返回如下一个 `Hash` 类型的结构：
+
+    {
+        "format"     => "jpeg",
+        "width"      => 640,
+        "height"     => 425,
+        "colorModel" => "ycbcr"
+    }
+
+format
+: 原始图片类型
+
+width
+: 原始图片宽度，单位像素
+
+height
+: 原始图片高度，单位像素
+
+colorModel
+: 原始图片着色模式
+
+<a name="image_preview_url"></a>
+
+#### 获取指定规格的缩略图预览地址
+
+    Qiniu::RS.image_preview_url(url, spec)
+
+使用 SDK 提供的 `Qiniu::RS.image_preview_url` 方法，可以基于一张存储于七牛云存储服务器上的图片，针对其下载链接，以及指定的缩略图规格类型，来获取该张图片的缩略图地址。
+
+**参数**
+
+url
+: 必须，字符串类型（String），图片的下载链接，需是 `Qiniu::RS.get`（或`Qiniu::RS.batch_get`）函数返回值中 `url` 字段的值，或者是 `Qiniu::RS.download`（或`Qiniu::RS.batch_download`）函数返回的下载链接。且文件本身必须是图片。
+
+spec
+: 可选，字符串或整型的枚举值，指定缩略图的具体规格，参考 [七牛云存储API之缩略图预览](/v2/api/foimg/#fo-imagePreview) 和 [自定义缩略图规格](/v2/api/foimg/#fo-imagePreviewEx) 。该值缺省为 0 （即输出宽800px高600px图片质量为85的缩略图）
+
+**返回值**
+
+返回一个字符串类型的缩略图 URL
+
+
+<a name="image_mogrify_preview_url"></a>
+
+#### 高级图像处理（缩略、裁剪、旋转、转化）
+
+`Qiniu::RS.image_mogrify_preview_url()` 方法支持将一个存储在七牛云存储的图片进行缩略、裁剪、旋转和格式转化处理，该方法返回一个可以直接预览缩略图的URL。
+
+    image_mogrify_preview_url = Qiniu::RS.image_mogrify_preview_url(source_image_url, mogrify_options)
+
+**参数**
+
+source_image_url
+: 必须，字符串类型（string），指定原始图片的下载链接，可以根据 rs.get() 获取到。
+
+mogrify_options
+: 必须，Hash Map 格式的图像处理参数。
+
+`mogrify_options` 对象具体的规格如下：
+
+    mogrify_options = {
+        :thumbnail => <ImageSizeGeometry>,
+        :gravity => <GravityType>, =NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast
+        :crop => <ImageSizeAndOffsetGeometry>,
+        :quality => <ImageQuality>,
+        :rotate => <RotateDegree>,
+        :format => <DestinationImageFormat>, =jpg, gif, png, tif, etc.
+        :auto_orient => <TrueOrFalse>
+    }
+
+`Qiniu::RS.image_mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](#/v2/api/foimg/#fo-imageMogr)。
+
+**返回值**
+
+返回一个可以预览最终缩略图的URL，String 类型。
+
+
+<a name="image_mogrify_save_as"></a>
+
+#### 高级图像处理（缩略、裁剪、旋转、转化）并持久化存储处理结果
+
+`Qiniu::RS.image_mogrify_save_as()` 方法支持将一个存储在七牛云存储的图片进行缩略、裁剪、旋转和格式转化处理，并且将处理后的缩略图作为一个新文件持久化存储到七牛云存储服务器上，这样就可以供后续直接使用而不用每次都传入参数进行图像处理。
+
+    result = Qiniu::RS.image_mogrify_save_as(target_bucket, target_key, src_img_url, mogrify_options)
+
+**参数**
+
+target_bucket
+: 必须，字符串类型（string），指定最终缩略图要存放的 bucket 。
+
+target_key
+: 必须，字符串类型（string），指定最终缩略图存放在云存储服务端的唯一文件ID。
+
+src_img_url
+: 必须，字符串类型（string），指定原始图片的下载链接，可以根据 rs.get() 获取到。
+
+mogrify_options
+: 必须，Hash Map 格式的图像处理参数。
+
+`mogrify_options` 对象具体的规格如下：
+
+    mogrify_options = {
+        :thumbnail => <ImageSizeGeometry>,
+        :gravity => <GravityType>, =NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast
+        :crop => <ImageSizeAndOffsetGeometry>,
+        :quality => <ImageQuality>,
+        :rotate => <RotateDegree>,
+        :format => <DestinationImageFormat>, =jpg, gif, png, tif, etc.
+        :auto_orient => <TrueOrFalse>
+    }
+
+`Qiniu::RS::Image.mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](#/v2/api/foimg/#fo-imageMogr)。
+
+**返回值**
+
+如果请求失败，返回 `false`；否则，返回如下一个 `Hash` 类型的结构：
+
+    {"hash" => "FrOXNat8VhBVmcMF3uGrILpTu8Cs"}
+
+示例代码：
+
+    data = Qiniu::RS.get("<test_image_bucket>", "<test_image_key>")
+    src_img_url = data["url"]
+
+    target_bucket = "test_thumbnails_bucket"
+    target_key = "cropped-" + @test_image_key
+
+    mogrify_options = {
+      :thumbnail => "!120x120r",
+      :gravity => "center",
+      :crop => "!120x120a0a0",
+      :quality => 85,
+      :rotate => 45,
+      :format => "jpg",
+      :auto_orient => true
+    }
+
+    result = Qiniu::RS.image_mogrify_save_as(target_bucket, target_key, src_img_url, mogrify_options)
+    if result
+      thumbnail = Qiniu::RS.get(target_bucket, target_key)
+      puts thumbnail["url"]
+
+      # 您可以选择将存放缩略图的 bucket 公开，这样就可以直接以外链的形式访问到缩略图，而不用走API获取下载URL。
+      result = Qiniu::RS.publish("pic.example.com", target_bucket)
+
+      # 然后将 pic.example.com CNAME 到 iovip.qbox.me ，就可以直接以如下方式访问缩略图
+      # [GET] http://pic.example.com/<target_key>
+    end
+
+
+<a name="Contributing"></a>
+
+## 贡献代码
+
+七牛云存储 Ruby SDK 源码地址：[https://github.com/qiniu/ruby-sdk](https://github.com/qiniu/ruby-sdk)
+
+1. 登录 [github.com](https://github.com)
+2. Fork [https://github.com/qiniu/ruby-sdk](https://github.com/qiniu/ruby-sdk)
+3. 创建您的特性分支 (`git checkout -b my-new-feature`)
+4. 提交您的改动 (`git commit -am 'Added some feature'`)
+5. 将您的改动记录提交到远程 `git` 仓库 (`git push origin my-new-feature`)
+6. 然后到 github 网站的该 `git` 远程仓库的 `my-new-feature` 分支下发起 Pull Request
+
+<a name="License"></a>
+
+## 许可证
+
+Copyright (c) 2012 qiniutek.com
+
+基于 MIT 协议发布:
+
+* [www.opensource.org/licenses/MIT](http://www.opensource.org/licenses/MIT)

lib/qiniu/rs.rb

@@ -12,6 +12,9 @@ module Qiniu
     autoload :IO, 'qiniu/rs/io'
     autoload :RS, 'qiniu/rs/rs'
     autoload :Image, 'qiniu/rs/image'
+    autoload :AccessToken, 'qiniu/tokens/access_token'
+    autoload :QboxToken, 'qiniu/tokens/qbox_token'
+    autoload :UploadToken, 'qiniu/tokens/upload_token'
 
     class << self
 
@@ -32,13 +35,23 @@ module Qiniu
       end
 
       def upload opts = {}
-        code, data = IO.put_file(opts[:url],
-                                 opts[:file],
+        code, data = IO.upload_file(opts[:url],
+                                    opts[:file],
+                                    opts[:bucket],
+                                    opts[:key],
+                                    opts[:mime_type],
+                                    opts[:note],
+                                    opts[:callback_params],
+                                    opts[:enable_crc32_check])
+        code == StatusOK
+      end
+
+      def put_file opts = {}
+        code, data = IO.put_file(opts[:file],
                                  opts[:bucket],
                                  opts[:key],
                                  opts[:mime_type],
                                  opts[:note],
-                                 opts[:callback_params],
                                  opts[:enable_crc32_check])
         code == StatusOK
       end
@@ -115,6 +128,30 @@ module Qiniu
         Image.preivew_url(url, spec)
       end
 
+      def image_mogrify_preview_url(source_image_url, options)
+        Image.mogrify_preview_url(source_image_url, options)
+      end
+
+      def image_mogrify_save_as(bucket, key, source_image_url, options)
+        code, data = RS.image_mogrify_save_as(bucket, key, source_image_url, options)
+        code == StatusOK ? data : false
+      end
+
+      #def generate_upload_token(scope, expires_in, callback_url = nil, return_url = nil)
+      #  Utils.generate_upload_token(scope, expires_in, callback_url, return_url)
+      #end
+
+      def generate_upload_token(opts = {})
+        token_obj = UploadToken.new(opts)
+        token_obj.access_key = Config.settings[:access_key]
+        token_obj.secret_key = Config.settings[:secret_key]
+        #token_obj.scope = opts[:scope]
+        #token_obj.expires_in = opts[:expires_in]
+        #token_obj.callback_url = opts[:callback_url]
+        #token_obj.return_url = opts[:return_url]
+        token_obj.generate_token
+      end
+
     end
 
   end

lib/qiniu/rs/auth.rb

@@ -38,7 +38,7 @@ module Qiniu
           @refresh_token = refresh_token
         end
 
-        def call(url, data, retry_times = 0)
+        def call_with_logged_in(url, data, retry_times = 0)
           raise MissingAccessToken if @access_token.nil?
           code, data = http_request url, data, {:access_token => @access_token}
           if code == 401
@@ -51,16 +51,25 @@ module Qiniu
             if code == 200
               retry_times += 1
               if Config.settings[:auto_reconnect] && retry_times < Config.settings[:max_retry_times]
-                return call(url, data, retry_times)
+                return call_with_logged_in(url, data, retry_times)
               end
             end
           end
           [code, data]
         end
 
+        def call_with_signature(url, data, retry_times = 0)
+          code, data = http_request url, data, {:qbox_signature_token => generate_qbox_signature(url, data)}
+          [code, data]
+        end
+
         def request(url, data = nil)
           begin
-            code, data = Auth.call(url, data)
+            if Config.settings[:access_key].empty? || Config.settings[:secret_key].empty?
+              code, data = Auth.call_with_logged_in(url, data)
+            else
+              code, data = Auth.call_with_signature(url, data)
+            end
           rescue [MissingAccessToken, MissingRefreshToken, MissingUsernameOrPassword] => e
             Log.logger.error e
             code, data = 401, {}

lib/qiniu/rs/config.rb

@@ -22,8 +22,10 @@ module Qiniu
           :auth_url        => "https://acc.qbox.me/oauth2/token",
           :rs_host         => "http://rs.qbox.me:10100",
           :io_host         => "http://iovip.qbox.me",
-          :client_id       => "",
-          :client_secret   => "",
+          :client_id       => "a75604760c4da4caaa456c0c5895c061c3065c5a",
+          :client_secret   => "75df554a39f58accb7eb293b550fa59618674b7d",
+          :access_key      => "",
+          :secret_key      => "",
           :auto_reconnect  => true,
           :max_retry_times => 5
         }

lib/qiniu/rs/image.rb

@@ -14,6 +14,24 @@ module Qiniu
           url + '/imagePreview/' + spec.to_s
         end
 
+        def mogrify_preview_url(source_image_url, options)
+          source_image_url + '?' + generate_mogrify_params_string(options)
+        end
+
+        def generate_mogrify_params_string(options = {})
+          opts = {}
+          options.each do |k, v|
+            opts[k.to_s] = v
+          end
+          params_string = ""
+          keys = ["thumbnail", "gravity", "crop", "quality", "rotate", "format"]
+          keys.each do |key|
+            params_string += %Q(/#{key}/#{opts[key]}) unless opts[key].nil?
+          end
+          params_string += '/auto-orient' unless opts["auto_orient"].nil?
+          'imageMogr' + params_string
+        end
+
       end
     end
   end

lib/qiniu/rs/io.rb

@@ -20,20 +20,34 @@ module Qiniu
           Auth.request(url)
         end
 
-        def put_file(url, local_file, bucket = nil, key = nil, mime_type = nil, custom_meta = nil, callback_params = nil, enable_crc32_check = false)
-          raise NoSuchFileError unless File.exist?(local_file)
+        def upload_file(url, local_file, bucket, key = nil, mime_type = nil, custom_meta = nil, callback_params = nil, enable_crc32_check = false)
+          action_params = _generate_action_params(local_file, bucket, key, mime_type, custom_meta, enable_crc32_check)
+          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type} if callback_params.nil?
+          callback_query_string = Utils.generate_query_string(callback_params)
+          Utils.upload_multipart_data(url, local_file, action_params, callback_query_string)
+        end
+
+        def put_file(local_file, bucket, key = nil, mime_type = nil, custom_meta = nil, enable_crc32_check = false)
+          action_params = _generate_action_params(local_file, bucket, key, mime_type, custom_meta, enable_crc32_check)
+          url = Config.settings[:io_host] + action_params
+          post_data = {:file => File.new(local_file, 'rb'), :multipart => true}
+          options = {:qbox_signature_token => Utils.generate_qbox_signature(url, nil)}
+          Utils.send_multipart_request url, post_data, options
+        end
+
+        private
+        def _generate_action_params(local_file, bucket, key = nil, mime_type = nil, custom_meta = nil, enable_crc32_check = false)
+          raise NoSuchFileError, local_file unless File.exist?(local_file)
           key = Digest::SHA1.hexdigest(local_file + Time.now.to_s) if key.nil?
           entry_uri = bucket + ':' + key
-          if mime_type.nil?
+          if mime_type.nil? || mime_type.empty?
             mime = MIME::Types.type_for local_file
             mime_type = mime.empty? ? 'application/octet-stream' : mime[0].content_type
           end
           action_params = '/rs-put/' + Utils.urlsafe_base64_encode(entry_uri) + '/mimeType/' + Utils.urlsafe_base64_encode(mime_type)
           action_params += '/meta/' + Utils.urlsafe_base64_encode(custom_meta) unless custom_meta.nil?
           action_params += '/crc32/' + Utils.crc32checksum(local_file).to_s if enable_crc32_check
-          callback_params = {:bucket => bucket, :key => key, :mime_type => mime_type} if callback_params.nil?
-          callback_query_string = Utils.generate_query_string(callback_params)
-          Utils.upload_multipart_data(url, local_file, action_params, callback_query_string)
+          action_params
         end
 
       end

lib/qiniu/rs/rs.rb

@@ -57,6 +57,18 @@ module Qiniu
           batch("delete", bucket, keys)
         end
 
+        def save_as(bucket, key, source_url, op_params_string)
+          encoded_uri = encode_entry_uri(bucket, key)
+          save_as_string = '/save-as/' + encoded_uri
+          new_url = source_url + '?' + op_params_string + save_as_string
+          Auth.request new_url
+        end
+
+        def image_mogrify_save_as(bucket, key, source_image_url, options)
+          mogrify_params_string = Image.generate_mogrify_params_string(options)
+          save_as(bucket, key, source_image_url, mogrify_params_string)
+        end
+
       end
     end
   end

lib/qiniu/rs/utils.rb

@@ -5,6 +5,7 @@ require 'json'
 require 'zlib'
 require 'base64'
 require 'rest_client'
+require 'hmac-sha1'
 require 'qiniu/rs/exceptions'
 
 module Qiniu
@@ -37,7 +38,15 @@ module Qiniu
           :accept => :json,
           :user_agent => Config.settings[:user_agent]
         }
-        header_options.merge!('Authorization' => "Bearer #{options[:access_token]}") if options[:access_token]
+        auth_token = nil
+        if !options[:qbox_signature_token].nil? && !options[:qbox_signature_token].empty?
+          auth_token = 'QBox ' + options[:qbox_signature_token]
+        #elsif !options[:upload_signature_token].nil? && !options[:upload_signature_token].empty?
+        #  auth_token = 'UpToken ' + options[:upload_signature_token]
+        elsif options[:access_token]
+          auth_token = 'Bearer ' + options[:access_token]
+        end
+        header_options.merge!('Authorization' => auth_token) unless auth_token.nil?
         case options[:method]
         when :get
           response = RestClient.get url, header_options
@@ -82,19 +91,22 @@ module Qiniu
         end
       end
 
-      def upload_multipart_data(url, filepath, action_string, callback_query_string = '')
+      def send_multipart_request(url, post_data, options = {})
         code, data = 0, {}
         begin
           header_options = {
             :accept => :json,
             :user_agent => Config.settings[:user_agent]
           }
-          post_data = {
-            :file => File.new(filepath, 'rb'),
-            :params => callback_query_string,
-            :action => action_string,
-            :multipart => true
-          }
+          auth_token = nil
+          if !options[:qbox_signature_token].nil? && !options[:qbox_signature_token].empty?
+            auth_token = 'QBox ' + options[:qbox_signature_token]
+          #elsif !options[:upload_signature_token].nil? && !options[:upload_signature_token].empty?
+            #auth_token = 'UpToken ' + options[:upload_signature_token]
+          elsif options[:access_token]
+            auth_token = 'Bearer ' + options[:access_token]
+          end
+          header_options.merge!('Authorization' => auth_token) unless auth_token.nil?
           response = RestClient.post url, post_data, header_options
           body = response.respond_to?(:body) ? response.body : ""
           data = safe_json_parse(body) unless body.empty?
@@ -114,6 +126,16 @@ module Qiniu
         [code, data]
       end
 
+      def upload_multipart_data(url, filepath, action_string, callback_query_string = '')
+          post_data = {
+            :file => File.new(filepath, 'rb'),
+            :params => callback_query_string,
+            :action => action_string,
+            :multipart => true
+          }
+          send_multipart_request(url, post_data)
+      end
+
       def generate_query_string(params)
         return params if params.is_a?(String)
         total_param = params.map { |key, value| key.to_s+"="+value.to_s }
@@ -124,6 +146,39 @@ module Qiniu
         File.open(filepath, "rb") { |f| Zlib.crc32 f.read }
       end
 
+      def generate_qbox_signature(url, params)
+        access_key = Config.settings[:access_key]
+        secret_key = Config.settings[:secret_key]
+        uri = URI.parse(url)
+        signature = uri.path
+        query_string = uri.query
+        signature += '?' + query_string if !query_string.nil? && !query_string.empty?
+        signature += "\n";
+        if params.is_a?(Hash)
+            total_param = params.map { |key, value| key.to_s+"="+value.to_s }
+            signature += total_param.join("&")
+        end
+        hmac = HMAC::SHA1.new(secret_key)
+        hmac.update(signature)
+        encoded_digest = urlsafe_base64_encode(hmac.digest)
+        %Q(#{access_key}:#{encoded_digest})
+      end
+
+=begin
+      def generate_upload_token(scope, expires_in, callback_url = nil, return_url = nil)
+        access_key = Config.settings[:access_key]
+        secret_key = Config.settings[:secret_key]
+        params = {:scope => scope, :deadline => Time.now.to_i + expires_in}
+        params[:callbackUrl] = callback_url if !callback_url.nil? && !calback_url.empty?
+        params[:returnUrl] = return_url if !return_url.nil? && !return_url.empty?
+        signature = urlsafe_base64_encode(params.to_json)
+        hmac = HMAC::SHA1.new(secret_key)
+        hmac.update(signature)
+        encoded_digest = urlsafe_base64_encode(hmac.digest)
+        %Q(#{access_key}:#{encoded_digest}:#{signature})
+      end
+=end
+
     end
   end
 end

lib/qiniu/rs/version.rb

@@ -2,6 +2,6 @@
 
 module Qiniu
   module RS
-    VERSION = "1.1.0"
+    VERSION = "2.3.0"
   end
 end

lib/qiniu/tokens/access_token.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'hmac-sha1'
+require 'qiniu/rs/config'
+require 'qiniu/rs/utils'
+
+module Qiniu
+  module RS
+      class AccessToken
+
+        include Utils
+
+        attr_accessor :access_key, :secret_key
+
+        def generate_encoded_digest(signature)
+          hmac = HMAC::SHA1.new(@secret_key)
+          hmac.update(signature)
+          urlsafe_base64_encode(hmac.digest)
+        end
+
+      end
+  end
+end

lib/qiniu/tokens/qbox_token.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+
+module Qiniu
+  module RS
+      class QboxToken < AccessToken
+
+        attr_accessor :url, :params
+
+        def initialize(opts = {})
+          @url = opts[:url]
+          @params = opts[:params]
+        end
+
+        def generate_signature
+          uri = URI.parse(@url)
+          signature = uri.path
+          query_string = uri.query
+          signature += '?' + query_string if !query_string.nil? && !query_string.empty?
+          signature += "\n";
+          if @params.is_a?(Hash)
+            total_param = @params.map { |key, value| key.to_s+"="+value.to_s }
+            signature += total_param.join("&")
+          end
+          signature
+        end
+
+        def generate_token
+          encoded_digest = generate_encoded_digest(signature)
+          %Q(#{@access_key}:#{encoded_digest})
+        end
+
+      end
+  end
+end

lib/qiniu/tokens/upload_token.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'json'
+require 'qiniu/tokens/access_token'
+require 'qiniu/rs/utils'
+
+module Qiniu
+  module RS
+      class UploadToken < AccessToken
+
+        include Utils
+
+        attr_accessor :scope, :expires_in, :callback_url, :return_url
+
+        def initialize(opts = {})
+          @scope = opts[:scope]
+          @expires_in = opts[:expires_in]
+          @callback_url = opts[:callback_url]
+          @return_url = opts[:return_url]
+        end
+
+        def generate_signature
+          params = {:scope => @scope, :deadline => Time.now.to_i + @expires_in}
+          params[:callbackUrl] = @callback_url if !@callback_url.nil? && !@calback_url.empty?
+          params[:returnUrl] = @return_url if !@return_url.nil? && !@return_url.empty?
+          urlsafe_base64_encode(params.to_json)
+        end
+
+        def generate_token
+          signature = generate_signature
+          encoded_digest = generate_encoded_digest(signature)
+          %Q(#{@access_key}:#{encoded_digest}:#{signature})
+        end
+
+      end
+  end
+end

qiniu-rs.gemspec

@@ -5,9 +5,9 @@ require File.expand_path('../lib/qiniu/rs/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["why404"]
   gem.email         = ["why404@gmail.com"]
-  gem.description   = %q{Qiniu Cloud Storage SDK for Ruby. See: http://docs.qiniutek.com/v1/sdk/ruby/}
-  gem.summary       = %q{Qiniu Cloud Storage SDK for Ruby}
-  gem.homepage      = "https://github.com/why404/qiniu-rs"
+  gem.description   = %q{Qiniu Resource (Cloud) Storage SDK for Ruby. See: http://docs.qiniutek.com/v2/sdk/ruby/}
+  gem.summary       = %q{Qiniu Resource (Cloud) Storage SDK for Ruby}
+  gem.homepage      = "https://github.com/qiniu/ruby-sdk"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -17,11 +17,12 @@ Gem::Specification.new do |gem|
   gem.version       = Qiniu::RS::VERSION
 
   # specify any dependencies here; for example:
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
-  gem.add_development_dependency "fakeweb"
-  gem.add_runtime_dependency "json"
-  gem.add_runtime_dependency "rest-client"
-  gem.add_runtime_dependency "mime-types"
-  gem.add_runtime_dependency "jruby-openssl" if RUBY_PLATFORM == "java"
+  gem.add_development_dependency "rake", "~> 0.9.2.2"
+  gem.add_development_dependency "rspec", "~> 2.10.0"
+  gem.add_development_dependency "fakeweb", "~> 1.3.0"
+  gem.add_runtime_dependency "json", "~> 1.7.3"
+  gem.add_runtime_dependency "rest-client", "~> 1.6.7"
+  gem.add_runtime_dependency "mime-types", "~> 1.19"
+  gem.add_runtime_dependency "ruby-hmac", "~> 0.4.0"
+  gem.add_runtime_dependency "jruby-openssl", "~> 0.7.7" if RUBY_PLATFORM == "java"
 end

spec/qiniu/rs/image_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'qiniu/rs/auth'
-require 'qiniu/rs/rs'
+require 'qiniu/rs'
 require 'qiniu/rs/image'
 
 module Qiniu
@@ -10,6 +10,7 @@ module Qiniu
     describe Image do
 
       before :all do
+=begin
         code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
         code.should == 200
         data.should be_an_instance_of(Hash)
@@ -17,25 +18,60 @@ module Qiniu
         data["refresh_token"].should_not be_empty
         data["refresh_token"].should_not be_empty
         puts data.inspect
+=end
 
-        @bucket = "test_images"
-        @key = "test_image.jpg"
-        code2, data2 = Qiniu::RS::RS.get(@bucket, @key)
-        code2.should == 200
-        data2["url"].should_not be_empty
-        puts data2.inspect
+        @bucket = "test_images_12345"
+        @key = "image_logo_for_test.png"
 
-        @download_url = data2["url"]
+        local_file = File.expand_path('../' + @key, __FILE__)
+
+        result = Qiniu::RS.drop(@bucket)
+        result.should_not be_false
+        puts result.inspect
+
+        put_url = Qiniu::RS.put_auth(10)
+        put_url.should_not be_false
+        put_url.should_not be_empty
+        result = Qiniu::RS.upload :url => put_url,
+                                  :file => local_file,
+                                  :bucket => @bucket,
+                                  :key => @key,
+                                  :mime_type => "image/png",
+                                  :enable_crc32_check => true
+        result.should be_true
+
+
+        result = Qiniu::RS.get(@bucket, @key)
+        result["url"].should_not be_empty
+        puts result.inspect
+        @source_image_url = result["url"]
+
+        @mogrify_options = {
+            :thumbnail => "!120x120r",
+            :gravity => "center",
+            :crop => "!120x120a0a0",
+            :quality => 85,
+            :rotate => 45,
+            :format => "jpg",
+            :auto_orient => true
+        }
       end
 
       context ".info" do
         it "should works" do
-          code, data = Qiniu::RS::Image.info(@download_url)
+          code, data = Qiniu::RS::Image.info(@source_image_url)
           code.should == 200
           puts data.inspect
         end
       end
 
+      context ".mogrify_preview_url" do
+        it "should works" do
+          mogrify_preview_url = Qiniu::RS::Image.mogrify_preview_url(@source_image_url, @mogrify_options)
+          puts mogrify_preview_url.inspect
+        end
+      end
+
     end
   end
 end

spec/qiniu/rs/io_spec.rb

@@ -10,6 +10,7 @@ module Qiniu
     describe IO do
 
       before :all do
+=begin
         code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
         code.should == 200
         data.should be_an_instance_of(Hash)
@@ -17,21 +18,27 @@ module Qiniu
         data["refresh_token"].should_not be_empty
         data["refresh_token"].should_not be_empty
         puts data.inspect
-
-        code2, data2 = Qiniu::RS::IO.put_auth()
-        code2.should == 200
-        data2["url"].should_not be_empty
-        data2["expiresIn"].should_not be_zero
-        puts data2.inspect
-
-        @put_url = data2["url"]
+=end
         @bucket = "test"
         @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
       end
 
+      context ".upload_file" do
+        it "should works" do
+          code, data = Qiniu::RS::IO.put_auth()
+          code.should == 200
+          data["url"].should_not be_empty
+          data["expiresIn"].should_not be_zero
+          puts data.inspect
+          code2, data2 = Qiniu::RS::IO.upload_file(data["url"], __FILE__, @bucket, @key)
+          code2.should == 200
+          puts data2.inspect
+        end
+      end
+
       context ".put_file" do
         it "should works" do
-          code, data = Qiniu::RS::IO.put_file(@put_url, __FILE__, @bucket, @key)
+          code, data = Qiniu::RS::IO.put_file(__FILE__, @bucket, @key, 'application/x-ruby', 'customMeta', true)
           code.should == 200
           puts data.inspect
         end

spec/qiniu/rs/rs_spec.rb

@@ -11,6 +11,7 @@ module Qiniu
     describe RS do
 
       before :all do
+=begin
         code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
         code.should == 200
         data.should be_an_instance_of(Hash)
@@ -18,6 +19,7 @@ module Qiniu
         data["refresh_token"].should_not be_empty
         data["refresh_token"].should_not be_empty
         puts data.inspect
+=end
 
         code2, data2 = Qiniu::RS::IO.put_auth()
         code2.should == 200
@@ -31,9 +33,9 @@ module Qiniu
         @domain = 'cdn.example.com'
       end
 
-      context "IO.put_file" do
+      context "IO.upload_file" do
         it "should works" do
-          code, data = Qiniu::RS::IO.put_file(@put_url, __FILE__, @bucket, @key)
+          code, data = Qiniu::RS::IO.upload_file(@put_url, __FILE__, @bucket, @key)
           code.should == 200
           puts data.inspect
         end

spec/qiniu/rs_spec.rb

@@ -10,14 +10,19 @@ module Qiniu
       @bucket = 'qiniu_rs_test'
       @key = Digest::SHA1.hexdigest Time.now.to_s
       @domain = 'cdn.example.com'
+
+      @test_image_bucket = 'test_images_12345'
+      @test_image_key = 'image_logo_for_test.png'
     end
 
+=begin
     context ".login!" do
       it "should works" do
         result = Qiniu::RS.login!("test@qbox.net", "test")
         result.should be_true
       end
     end
+=end
 
     context ".put_auth" do
       it "should works" do
@@ -38,11 +43,23 @@ module Qiniu
                                   :file =>  __FILE__,
                                   :bucket => @bucket,
                                   :key => @key,
+                                  :mime_type => 'application/x-ruby',
                                   :enable_crc32_check => true
         result.should be_true
       end
     end
 
+    context ".put_file" do
+      it "should works" do
+        result = Qiniu::RS.put_file :file =>  __FILE__,
+                                    :bucket => @bucket,
+                                    :key => @key,
+                                    :mime_type => 'application/x-ruby',
+                                    :enable_crc32_check => true
+        result.should be_true
+      end
+    end
+
     context ".stat" do
       it "should works" do
         result = Qiniu::RS.stat(@bucket, @key)
@@ -136,7 +153,7 @@ module Qiniu
 
     context ".image_info" do
       it "should works" do
-        data = Qiniu::RS.get("test_images", "test_image.jpg")
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
         data.should_not be_false
         data.should_not be_empty
         puts data.inspect
@@ -147,5 +164,39 @@ module Qiniu
       end
     end
 
+    context ".image_mogrify_save_as" do
+      it "should works" do
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
+        data.should_not be_false
+        data.should_not be_empty
+        puts data.inspect
+
+        dest_bucket = "test_thumbnails_bucket"
+        dest_key = "cropped-" + @test_image_key
+        src_img_url = data["url"]
+        mogrify_options = {
+          :thumbnail => "!120x120r",
+          :gravity => "center",
+          :crop => "!120x120a0a0",
+          :quality => 85,
+          :rotate => 45,
+          :format => "jpg",
+          :auto_orient => true
+        }
+        result = Qiniu::RS.image_mogrify_save_as(dest_bucket, dest_key, src_img_url, mogrify_options)
+        result.should_not be_false
+        result.should_not be_empty
+        puts result.inspect
+      end
+    end
+
+    context ".generate_upload_token" do
+      it "should works" do
+        data = Qiniu::RS.generate_upload_token({:scope => 'test_bucket', :expires_in => 3600})
+        data.should_not be_empty
+        puts data.inspect
+      end
+    end
+
   end
 end

spec/spec_helper.rb

@@ -6,7 +6,7 @@ require 'rspec'
 
 RSpec.configure do |config|
   config.before :all do
-    Qiniu::RS.establish_connection! :client_id     => "abcd0c7edcdf914228ed8aa7c6cee2f2bc6155e2",
-                                    :client_secret => "fc9ef8b171a74e197b17f85ba23799860ddf3b9c"
+    Qiniu::RS.establish_connection! :access_key => "3fPHl_SLkPXdioqI_A8_NGngPWVJhlDk2ktRjogH",
+                                    :secret_key => "bXTPMDJrVYRJUiSDRFtFYwycVD_mjXxYWrCYlDHy"
   end
 end