Merge pull request #13 from why404/hotfix/v3.0.2

update spec - removed pub2 test

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qiniu-rs (2.0.4)
+    qiniu-rs (3.0.2)
       json (~> 1.7.3)
       mime-types (~> 1.19)
       rest-client (~> 1.6.7)
@@ -12,19 +12,19 @@ GEM
   specs:
     diff-lcs (1.1.3)
     fakeweb (1.3.0)
-    json (1.7.3)
+    json (1.7.4)
     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)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
+    rspec-mocks (2.11.2)
     ruby-hmac (0.4.0)
 
 PLATFORMS
@@ -33,5 +33,5 @@ PLATFORMS
 DEPENDENCIES
   fakeweb (~> 1.3.0)
   qiniu-rs!
-  rake (~> 0.9.2.2)
-  rspec (~> 2.10.0)
+  rake (~> 0.9)
+  rspec (~> 2.11)

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, jruby, rbx, ree 版本，基于 [七牛云存储官方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/v3/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。
 
 ## 安装
 
@@ -20,7 +20,7 @@
 
 ## 使用
 
-参考文档：[七牛云存储 Ruby SDK 使用指南](http://docs.qiniutek.com/v2/sdk/ruby/)
+参考文档：[七牛云存储 Ruby SDK 使用指南](http://docs.qiniutek.com/v3/sdk/ruby/)
 
 ## 贡献代码
 
@@ -32,7 +32,7 @@
 
 ## 许可证
 
-Copyright (c) 2012 why404
+Copyright (c) 2012 qiniutek.com
 
 基于 MIT 协议发布:
 

docs/README.md

@@ -0,0 +1,988 @@
+---
+title: Ruby SDK 使用指南 | 七牛云存储
+---
+
+# Ruby SDK 使用指南
+
+此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](/v3/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)
+        - [获取用于上传文件的临时授权凭证](#generate-upload-token)
+        - [服务端上传文件](#upload-server-side)
+            - [针对 NotFound 场景处理](#upload-file-for-not-found)
+        - [客户端直传文件](#upload-client-side)
+    - [查看文件属性信息](#stat)
+    - [获取文件下载链接（含文件属性信息）](#get)
+    - [只获取文件下载链接](#download)
+    - [删除指定文件](#delete)
+    - [删除所有文件（单个 bucket）](#drop)
+    - [批量操作](#batch)
+        - [批量获取文件属性信息（含下载链接）](#batch_get)
+        - [批量获取文件下载链接](#batch_download)
+        - [批量删除文件](#batch_delete)
+    - [创建公开外链](#publish)
+    - [取消公开外链](#unpublish)
+    - [Bucket（资源表）管理](#buckets)
+        - [创建 Bucket](#mkbucket)
+        - [列出所有 Bucket](#list-all-buckets)
+        - [访问控制](#set-protected)
+    - [图像处理](#op-image)
+        - [查看图片属性信息](#image_info)
+        - [查看图片EXIF信息](#image_exif)
+        - [获取指定规格的缩略图预览地址](#image_preview_url)
+        - [高级图像处理（缩略、裁剪、旋转、转化）](#image_mogrify_preview_url)
+        - [高级图像处理（缩略、裁剪、旋转、转化）并持久化](#image_mogrify_save_as)
+        - [高级图像处理（水印）](#image-watermarking)
+            - [水印准备工作](#watermarking-pre-work)
+                - [设置原图保护](#watermarking-set-protected)
+                - [设置水印预览图URL分隔符](#watermarking-set-sep)
+                - [设置水印预览图规格别名](#watermarking-set-style)
+            - [设置水印模板](#watermarking-set-template)
+            - [获取水印模板](#watermarking-get-template)
+
+- [贡献代码](#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="generate-upload-token"></a>
+
+#### 获取用于上传文件的临时授权凭证
+
+要上传一个文件，首先需要调用 SDK 提供的 `Qiniu::RS.generate_upload_token` 函数来获取一个经过授权用于临时匿名上传的 `upload_token`——经过数字签名的一组数据信息，该 `upload_token` 作为文件上传流中 `multipart/form-data` 的一部分进行传输。
+
+`Qiniu::RS.generate_upload_token` 函数原型如下：
+
+    Qiniu::RS.generate_upload_token :scope              => target_bucket,
+                                    :expires_in         => expires_in_seconds,
+                                    :callback_url       => callback_url,
+                                    :callback_body_type => callback_body_type,
+                                    :customer           => end_user_id
+
+**参数**
+
+:scope
+: 必须，字符串类型（String），设定文件要上传到的目标 `bucket`
+
+:expires_in
+: 可选，数字类型，用于设置上传 URL 的有效期，单位：秒，缺省为 3600 秒，即 1 小时后该上传链接不再有效（但该上传URL在其生成之后的59分59秒都是可用的）。
+
+:callback_url
+: 可选，字符串类型（String），用于设置文件上传成功后，七牛云存储服务端要回调客户方的业务服务器地址。
+
+:callback_body_type
+: 可选，字符串类型（String），用于设置文件上传成功后，七牛云存储服务端向客户方的业务服务器发送回调请求的 `Content-Type`。
+
+:customer
+: 可选，字符串类型（String），客户方终端用户（End User）的ID，该字段可以用来标示一个文件的属主，这在一些特殊场景下（比如给终端用户上传的图片打上名字水印）非常有用。
+
+**返回值**
+
+返回一个字符串类型（String）的用于上传文件用的临时授权 `upload_token`。
+
+<a name="upload-server-side"></a>
+
+#### 服务端上传文件
+
+通过 `Qiniu::RS.upload_file()` 方法可在客户方的业务服务器上直接往七牛云存储上传文件。该函数规格如下：
+
+    Qiniu::RS.upload_file :uptoken            => upload_token,
+                          :file               => file_path,
+                          :bucket             => bucket_name,
+                          :key                => record_id,
+                          :mime_type          => file_mime_type,
+                          :note               => some_notes,
+                          :callback_params    => callback_params,
+                          :enable_crc32_check => false
+
+**参数**
+
+:uptoken
+: 必须，字符串类型（String），调用 `Qiniu::RS.generate_upload_token` 生成的 [用于上传文件的临时授权凭证](#generate-upload-token)
+
+:file
+: 必须，字符串类型（String），本地文件可被读取的有效路径
+
+:bucket
+: 必须，字符串类型（String），类似传统数据库里边的表名称，我们暂且将其叫做“资源表”，指定将该数据属性信息存储到具体的资源表中 。
+
+:key
+: 必须，字符串类型（String），类似传统数据库里边某个表的主键ID，给每一个文件一个UUID用于进行标示。
+
+:mime_type
+: 可选，字符串类型（String），文件的 mime-type 值。如若不传入，SDK 会自行计算得出，若计算失败缺省使用 application/octet-stream 代替之。
+
+:note
+: 可选，字符串类型（String），为文件添加备注信息。
+
+:callback_params
+: 可选，String 或者 Hash 类型，文件上传成功后，七牛云存储向客户方业务服务器发送的回调参数。
+
+:enable_crc32_check
+: 可选，Boolean 类型，是否启用文件上传 crc32 校验，缺省为 false 。
+
+**返回值**
+
+上传成功，返回如下一个 Hash，否则返回 `false`：
+
+    {"hash"=>"FgHk-_iqpnZji6PsNr4ghsK5qEwR"}
+
+<a name="upload-file-for-not-found"></a>
+
+##### 针对 NotFound 场景处理
+
+您可以上传一个应对 HTTP 404 出错处理的文件，当您 [创建公开外链](#publish) 后，若公开的外链找不到该文件，即可使用您上传的“自定义404文件”代替之。要这么做，您只须使用 `Qiniu::RS.upload_file` 函数上传一个 `key` 为固定字符串类型的值 `errno-404` 即可。
+
+除了使用 SDK 提供的方法，同样也可以借助七牛云存储提供的命令行辅助工具 [qboxrsctl](https://github.com/qiniu/devtools/tags) 达到同样的目的：
+
+    qboxrsctl put <Bucket> <Key> <LocalFile>
+
+将其中的 `<Key>` 换作  `errno-404` 即可。
+
+注意，每个 `<Bucket>` 里边有且只有一个 `errno-404` 文件，上传多个，最后的那一个会覆盖前面所有的。
+
+<a name="upload-client-side"></a>
+
+#### 客户端直传文件
+
+客户端上传流程和服务端上传类似，差别在于：客户端直传文件所需的 `upload_token` 可以选择在客户方的业务服务器端生成，也可以选择在客户方的客户端程序里边生成。选择前者，可以和客户方的业务揉合得更紧密和安全些，比如防伪造请求。
+
+简单来讲，客户端上传流程也分为两步：
+
+1. 获取 `upload_token`（[用于上传文件的临时授权凭证](#generate-upload-token)）
+2. 将该 `upload_token` 作为文件上传流 `multipart/form-data` 中的一部分实现上传操作
+
+如果您的网络程序是从云端（服务端程序）到终端（手持设备应用）的架构模型，且终端用户有使用您移动端App上传文件（比如照片或视频）的需求，可以把您服务器得到的此 `upload_token` 返回给手持设备端的App，然后您的移动 App 可以使用 [七牛云存储 Objective-SDK （iOS）](http://docs.qiniutek.com/v3/sdk/objc/) 或 [七牛云存储 Android-SDK](http://docs.qiniutek.com/v3/sdk/android/) 的相关上传函数或参照 [七牛云存储API之文件上传](http://docs.qiniutek.com/v3/api/io/#upload) 直传文件。这样，您的终端用户即可把数据（比如图片或视频）直接上传到七牛云存储服务器上无须经由您的服务端中转，而且在上传之前，七牛云存储做了智能加速，终端用户上传数据始终是离他物理距离最近的存储节点。当终端用户上传成功后，七牛云存储服务端会向您指定的 `callback_url` 发送回调数据。如果 `callback_url` 所在的服务处理完毕后输出 `JSON` 格式的数据，七牛云存储服务端会将该回调请求所得的响应信息原封不动地返回给终端应用程序。
+
+
+<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>
+
+### 删除所有文件（单个 bucket）
+
+    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`，也可以是七牛云存储的二级路径，比如 `iovip.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="buckets"></a>
+
+### Bucket（资源表）管理
+
+<a name="mkbucket"></a>
+
+#### 创建 Bucket
+
+    Qiniu::RS.mkbucket(bucket_name)
+
+可以通过 SDK 提供的 `Qiniu::RS.mkbucket` 函数创建一个 bucket（资源表）。
+
+**参数**
+
+bucket_name
+: 必须，字符串类型（String），资源表 bucket 的名称。
+
+**返回值**
+
+如果指定 bucket 创建成功，返回 `true`，否则返回 `false` 。
+
+<a name="list-all-buckets"></a>
+
+#### 列出所有 Bucket
+
+    Qiniu::RS.buckets
+
+可以通过 SDK 提供的 `Qiniu::RS.buckets` 函数列出当前登录客户的所有 buckets（资源表）。
+
+**返回值**
+
+如果请求成功，返回一个 buckets 的列表（Array），否则返回 `false` 。
+
+    ["Bucket1", "Bucket2", …, "BucketN"]
+
+<a name="set-protected"></a>
+
+#### 访问控制
+
+    Qiniu::RS.set_protected(bucket_name, protected_mode)
+
+可以通过 SDK 提供的 `Qiniu::RS.set_protected` 函数来设置指定 bucket 的访问属性，一般在水印处理时作原图保护用。
+
+**参数**
+
+bucket_name
+: 必须，字符串类型（String），指定资源表 bucket 的名称。
+
+protected_mode
+: 必须，整型，值为 1 或者 0，值为 1 表示启用保护模式，反之亦然。
+
+该函数不常用，一般在特殊场景下会用到。比如给图片打水印时，首先要设置原图保护，禁用公开的图像处理操作，采用水印的特殊图像处理，而保护原图就可以通过该函数操作实现。
+
+**返回值**
+
+如果设置成功，返回 `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_exif"></a>
+
+#### 查看图片EXIF信息
+
+    Qiniu::RS.image_exif(url)
+
+使用 SDK 提供的 `Qiniu::RS.image_exif` 方法，可以基于一张存储于七牛云存储服务器上的原始图片图片，取到该图片的  EXIF 信息。
+
+**参数**
+
+url
+: 必须，字符串类型（String），原图的下载链接，需是 `Qiniu::RS.get`（或`Qiniu::RS.batch_get`）函数返回值中 `url` 字段的值，或者是 `Qiniu::RS.download`（或`Qiniu::RS.batch_download`）函数返回的下载链接。且文件本身必须是图片。
+
+**返回值**
+
+如果参数 `url` 所代表的图片没有 EXIF 信息，返回 `false`。否则，返回一个包含 EXIF 信息的 Hash 结构。
+
+
+<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之缩略图预览](/v3/api/foimg/#fo-imagePreview) 和 [自定义缩略图规格](/v3/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` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](/v3/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` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](/v3/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="image-watermarking"></a>
+
+## 高级图像处理（水印）
+
+<a name="watermarking-pre-work"></a>
+
+### 水印准备工作
+
+为了保护用户原图和方便用户访问打过水印之后的图片，在经水印作用之前，需进行以下一些设置：
+
+1. [设置原图保护](#watermarking-set-protected)
+2. [设置水印预览图URL分隔符](#watermarking-set-sep)
+3. [设置水印预览图规格别名](#watermarking-set-style)
+
+<a name="watermarking-set-protected"></a>
+
+#### 1. 设置原图保护
+
+用户的图片打上水印后，其原图不可见。通过给原图所在的 Bucket（资源表）设置访问控制，可以达到保护原图的目的，详情请参考 [Bucket（资源表）管理之访问控制](set-protected)。
+
+设置原图保护也可以借助七牛云存储提供的命令行辅助工具 [qboxrsctl](https://github.com/qiniu/devtools/tags) 来实现：
+
+    // 为<Bucket>下面的所有图片设置原图保护
+    qboxrsctl protected <Bucket> <Protected>
+
+<a name="watermarking-set-sep"></a>
+
+#### 2. 设置水印预览图URL分隔符
+
+没有设置水印前，用户可以通过如下公开链接的形式访问原图（[创建公开外链后的情况下](/v3/api/io/#rs-Publish)）：
+
+    http://<Domain>/<Key>
+
+设置水印后，其原图属性为私有，不能再通过这种形式访问。但是用户可以在原图的 `<Key>` 后面加上“分隔符”，以及相应的水印风格样式来访问打水印后的图片。例如，假设您为用户设定的访问水印图的分隔符为中划线 “-”，那么用户可以通过这种形式来访问打水印后的图片：
+
+    http://<Domain>/<Key>-/imageView/<Mode>/w/<Width>/h/<Height>/q/<Quality>/format/<Format>/sharpen/<Sharpen>/watermark/<HasWatermark>
+
+其中，`HasWatermark` 参数为 `0` （或者没有）表示不打水印，为 `1` 表示给图片打水印。
+
+通过 SDK 提供的 `Qiniu::RS.set_separator` 函数可以设置水印预览图URL分隔符：
+
+    Qiniu::RS.set_separator(bucket_name, separator)
+
+**参数**
+
+bucket_name
+: 必须，字符串类型（String），图片所在的 Bucket（资源表） 名称
+
+separator
+: 必须，字符串类型（String），源图片与预览图规格之间的分割符
+
+**返回值**
+
+操作成功返回 `true`，否则返回 `false`。
+
+除了使用 SDK 提供的方法，同样可以借助七牛云存储提供的命令行辅助工具 [qboxrsctl](https://github.com/qiniu/devtools/tags) 达到同样的目的：
+
+    // 设置预览图分隔符
+    qboxrsctl separator <Bucket> <Sep>
+
+<a name="watermarking-set-style"></a>
+
+#### 3. 设置水印预览图规格别名
+
+通过步骤2中所描述的水印预览图 URL 来访问打水印后的图片毕竟较为繁琐，因此可以通过为该水印预览图规格设置“别名”的形式来访问。如：
+
+别名（Name） | 规格（Style） | 说明
+----------- | ------------ | -------
+small.jpg   | imageView/0/w/120/h/90 | 大小为 120x90，不打水印
+middle.jpg  | imageView/0/w/440/h/330/watermark/1 | 大小为 440x330，打水印
+large.jpg   | imageView/0/w/1280/h/760/watermark/1 | 大小为 1280x760，打水印
+
+
+SDK 提供了 `Qiniu::RS.set_style` 函数可以定义预览图规格别名，该函数原型如下：
+
+    Qiniu::RS.set_style(bucket, name, style)
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），图片所在的 Bucket（资源表） 名称
+
+name
+: 必须，字符串类型（String），预览图规格名称（别名）
+
+style
+: 必须，字符串类型（String），具体的规格样式
+
+**返回值**
+
+操作成功返回 `true`，否则返回 `false` 。
+
+除了使用 SDK 提供的方法，同样也可以借助七牛云存储提供的命令行辅助工具 [qboxrsctl](https://github.com/qiniu/devtools/tags) 达到同样的目的：
+
+    // 为 <Buecket> 下面的所有图片设置名为 <Name> 的 <Style>
+    qboxrsctl style <Bucket> <Name> <Style>
+
+无论是通过 SDK 提供的方法还是命令行辅助工具操作，在设置完成后，即可通过通过以下方式来访问设定规格后的图片：
+
+	// 其中 “-” 为分隔符，“small.jpg” 为预览图规格别名
+	[GET] http://<Domain>/<Key>-small.jpg
+
+	// 其中 “!” 为分隔符，“middle.jpg” 为预览图规格别名
+	[GET] http://<Domain>/<Key>!middle.jpg
+
+	// 其中 “@” 为分隔符，“large.jpg” 为预览图规格别名
+    [GET] http://<Domain>/<Key>@large.jpg
+
+以上这些设置水印模板前的准备只需操作一次，即可对后续设置的所有水印模板生效。由于是一次性操作，建议使用 qboxrsctl 命令行辅助工具进行相关设置。
+
+**取消水印预览图规格设置**
+
+您也可以为某个水印预览图规格取消“别名”设置，SDK 提供了相应的方法：
+
+    Qiniu::RS.unset_style(bucket, name)
+
+**参数**
+
+bucket
+: 必须，字符串类型（String），图片所在的 Bucket（资源表） 名称
+
+name
+: 必须，字符串类型（String），预览图规格名称（别名）
+
+**返回值**
+
+操作成功返回 `true`，否则返回 `false` 。
+
+除了使用 SDK 提供的方法，同样也可以借助七牛云存储提供的命令行辅助工具 [qboxrsctl](https://github.com/qiniu/devtools/tags) 达到同样的目的：
+
+    // 取消预览图规格别名为 <Name> 的 Style
+    qboxrsctl unstyle <Bucket> <Name>
+
+
+<a name="watermarking-set-template"></a>
+
+### 设置水印模板
+
+给图片加水印，SDK 提供了设置水印模板的函数：`Qiniu::RS.set_watermark` ，通过该函数操作，客户方可以设置通用的水印模板，也可以为客户方的每一个终端用户分别设置一个水印模板。
+
+`Qiniu::RS.set_watermark` 函数原型如下：
+
+    Qiniu::RS.set_watermark(customer_id, {
+        :font     => <FontName>,
+        :fontsize => <FontSize>,
+        :fill     => <FillColor>,
+        :text     => <WatermarkText>,
+        :bucket   => <LogoBucket>,
+        :dissolve => <Dissolve>,
+        :gravity  => <Gravity>,
+        :dx       => <DistanceX>,
+        :dy       => <DistanceY>
+    })
+
+**参数**：
+
+1. `customer_id = <EndUserID>`
+: 客户方终端用户标识。如果`customer_id`为 `nil`，则表示设置默认水印模板。作为面向终端用户的服务提供商，您可以为不同的用户设置不同的水印模板，只需在设置水印模板的时候传入`customer_id`参数。如果该参数未设置，则表示为终端用户设置一个默认模板。举例：假如您为终端用户提供的是一个手机拍照软件，用户拍照后图片存储于七牛云存储服务器。为了给每个用户所上传的图片打上标有该用户用户名的水印，您可以为该用户设置一个水印模板，其水印文字可以是该终端用户的用户名。但如果您未给该终端用户设置模板，那么水印上的所有设置都是默认的（其文字部分可能是你们自己设置的企业标识）。该 `customer_id` 和 [Qiniu::RS.generate_upload_token](#generate-upload-token) 中的 `customer` 参数含义一致，结合这点，您很容易想明白为什么 `Qiniu::RS.generate_upload_token` 函数中会有 `customer` 这个可选参数还有 `Qiniu::RS.set_watermark` 函数中会有 `customer_id` 参考以及两者间的关系。
+
+2. `:font => <FontName>`
+: 为水印上的文字设置一个默认的字体名，可选。
+
+3. `:fontsize => <FontSize>`
+: 字体大小，可选，0表示默认，单位: 缇，等于 1/20 磅。
+
+4. `:fill => <FillColor>`
+: 字体颜色，可选。
+
+5. `:text => <WatermarkText>`
+: 水印文字，必须，图片用 \0 - \9 占位。
+
+6. `:bucket => <ImageFromBucket>`
+: 如果水印中有图片，需要指定图片所在的 `RS Bucket` 名称，可选。
+
+7. `:dissolve => <Dissolve>`
+: 透明度，可选，字符串，如50%。
+
+8. `:gravity => <Gravity>`
+: 位置，可选，字符串，默认为右下角（SouthEast）。可选的值包括：NorthWest、North、NorthEast、West、Center、East、SouthWest、South和SouthEast。
+
+9. `:dx => <DistanceX>`
+: 横向边距，可选，默认值为10，单位px。
+
+10. `:dy => <DistanceY>`
+: 纵向边距，可选，默认值为10，单位px。
+
+**返回值**
+
+操作成功返回 `true`，否则返回 `false` 。
+
+
+<a name="watermarking-get-template"></a>
+
+### 获取水印模板
+
+SDK 提供了 `Qiniu::RS.get_watermark` 函数获取指定终端用户或者缺省的水印模板。该函数原型如下：
+
+    Qiniu::RS.get_watermark(customer_id = nil)
+
+**参数**
+
+customer_id
+: 客户方终端用户标识，可选，字符串类型，含义同 [Qiniu::RS.set_watermark](#watermarking-set-template) 函数中的 `customer_id` 参数。该值缺省为 `nil`，如果该值为 `nil`，则表示取默认的通用水印模板。
+
+**返回值**
+
+如果请求成功，返回如下一段 Hash 结构的数据；否则返回 `false`。
+
+    {
+    	font: <FontName>
+    	fontsize: <FontSize>
+    	fill: <FillColor>
+    	text: <WatermarkText>
+    	bucket: <LogoBucket>
+    	dissolve: <Dissolve>
+    	gravity: <Gravity>
+    	dx: <DistanceX>
+    	dy: <DistanceY>
+    }
+
+请求成功后返回数据的含义同 [设置水印模板](#watermarking-set-template) 时传入的参数一致。
+
+
+<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

@@ -11,7 +11,12 @@ module Qiniu
     autoload :Auth, 'qiniu/rs/auth'
     autoload :IO, 'qiniu/rs/io'
     autoload :RS, 'qiniu/rs/rs'
+    autoload :EU, 'qiniu/rs/eu'
+    autoload :Pub, 'qiniu/rs/pub'
     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
 
@@ -26,23 +31,85 @@ module Qiniu
         code == StatusOK
       end
 
+      def mkbucket(bucket_name)
+        code, data = RS.mkbucket(bucket_name)
+        code == StatusOK
+      end
+
+      def buckets
+        code, data = RS.buckets
+        code == StatusOK ? data : false
+      end
+
+      def set_protected(bucket, protected_mode)
+        code, data = Pub.set_protected(bucket, protected_mode)
+        code == StatusOK
+      end
+
+      def set_separator(bucket, separator)
+        code, data = Pub.set_separator(bucket, separator)
+        code == StatusOK
+      end
+
+      def set_style(bucket, name, style)
+        code, data = Pub.set_style(bucket, name, style)
+        code == StatusOK
+      end
+
+      def unset_style(bucket, name)
+        code, data = Pub.unset_style(bucket, name)
+        code == StatusOK
+      end
+
+      def set_watermark(customer_id, options = {})
+        code, data = EU.set_watermark(customer_id, options)
+        code == StatusOK
+      end
+
+      def get_watermark(customer_id = nil)
+        code, data = EU.get_watermark(customer_id)
+        code == StatusOK ? data : false
+      end
+
       def put_auth(expires_in = nil, callback_url = nil)
         code, data = IO.put_auth(expires_in, callback_url)
         code == StatusOK ? data["url"] : false
       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
 
+      def upload_file opts = {}
+        code, data = IO.upload_with_token(opts[:uptoken],
+                                          opts[:file],
+                                          opts[:bucket],
+                                          opts[:key],
+                                          opts[:mime_type],
+                                          opts[:note],
+                                          opts[:callback_params],
+                                          opts[:enable_crc32_check])
+        code == StatusOK ? data : false
+      end
+
       def stat(bucket, key)
         code, data = RS.stat(bucket, key)
         code == StatusOK ? data : false
@@ -111,10 +178,36 @@ module Qiniu
         code == StatusOK ? data : false
       end
 
+      def image_exif(url)
+        code, data = Image.exif(url)
+        code == StatusOK ? data : false
+      end
+
       def image_preview_url(url, spec)
         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(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.callback_body_type = opts[:callback_body_type]
+        #token_obj.customer = opts[:customer]
+        token_obj.generate_token
+      end
+
     end
 
   end

lib/qiniu/rs/auth.rb

@@ -58,17 +58,17 @@ module Qiniu
           [code, data]
         end
 
-        def call_with_signature(url, data, retry_times = 0)
-          code, data = http_request url, data, {:signature_auth => true}
+        def call_with_signature(url, data, retry_times = 0, options = {})
+          code, data = http_request url, data, options.merge({:qbox_signature_token => generate_qbox_signature(url, data)})
           [code, data]
         end
 
-        def request(url, data = nil)
+        def request(url, data = nil, options = {})
           begin
             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)
+              code, data = Auth.call_with_signature(url, data, 0, options)
             end
           rescue [MissingAccessToken, MissingRefreshToken, MissingUsernameOrPassword] => e
             Log.logger.error e

lib/qiniu/rs/config.rb

@@ -21,9 +21,10 @@ module Qiniu
           :content_type    => 'application/x-www-form-urlencoded',
           :auth_url        => "https://acc.qbox.me/oauth2/token",
           :rs_host         => "http://rs.qbox.me:10100",
-          #:rs_host         => "http://localhost:10100",
           :io_host         => "http://iovip.qbox.me",
-          #:io_host         => "http://localhost:10200",
+          :up_host         => "http://up.qbox.me",
+          :pub_host        => "http://pu.qbox.me:10200",
+          :eu_host         => "http://eu.qbox.me",
           :client_id       => "a75604760c4da4caaa456c0c5895c061c3065c5a",
           :client_secret   => "75df554a39f58accb7eb293b550fa59618674b7d",
           :access_key      => "",

lib/qiniu/rs/eu.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module EU
+      class << self
+        include Utils
+
+        def set_watermark(customer_id, options = {})
+          Auth.request Config.settings[:eu_host] + '/wmset', options.merge({:customer => customer_id})
+        end
+
+        def get_watermark(customer_id = nil)
+          post_data = customer_id.nil? ? nil : {:customer => customer_id}
+          Auth.request Config.settings[:eu_host] + '/wmget', post_data
+        end
+
+      end
+    end
+  end
+end
+

lib/qiniu/rs/image.rb

@@ -10,10 +10,32 @@ module Qiniu
           Utils.http_request url + '/imageInfo', nil, {:method => :get}
         end
 
+        def exif(url)
+          Utils.http_request url + '?exif', nil, {:method => :get}
+        end
+
         def preivew_url(url, spec)
           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' + URI.escape(params_string)
+        end
+
       end
     end
   end

lib/qiniu/rs/io.rb

@@ -20,20 +20,41 @@ 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
+          options = {:content_type => 'application/octet-stream'}
+          Auth.request url, ::IO.read(local_file), options
+        end
+
+        def upload_with_token(uptoken, 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)
+          url = Config.settings[:up_host] + '/upload'
+          Utils.upload_multipart_data(url, local_file, action_params, callback_query_string, uptoken)
+        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/pub.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+module Qiniu
+  module RS
+    module Pub
+      class << self
+        include Utils
+
+        def set_protected(bucket, protected_mode)
+          host = Config.settings[:pub_host]
+          Auth.request %Q(#{host}/accessMode/#{bucket}/mode/#{protected_mode})
+        end
+
+        def set_separator(bucket, separator)
+          host = Config.settings[:pub_host]
+          encoded_separator = Utils.urlsafe_base64_encode(separator)
+          Auth.request %Q(#{host}/separator/#{bucket}/sep/#{encoded_separator})
+        end
+
+        def set_style(bucket, name, style)
+          host = Config.settings[:pub_host]
+          encoded_name = Utils.urlsafe_base64_encode(name)
+          encoded_style = Utils.urlsafe_base64_encode(style)
+          Auth.request %Q(#{host}/style/#{bucket}/name/#{encoded_name}/style/#{encoded_style})
+        end
+
+        def unset_style(bucket, name)
+          host = Config.settings[:pub_host]
+          encoded_name = Utils.urlsafe_base64_encode(name)
+          Auth.request %Q(#{host}/unstyle/#{bucket}/name/#{encoded_name})
+        end
+
+      end
+    end
+  end
+end
+

lib/qiniu/rs/rs.rb

@@ -6,6 +6,14 @@ module Qiniu
       class << self
         include Utils
 
+        def buckets
+          Auth.request Config.settings[:rs_host] + '/buckets'
+        end
+
+        def mkbucket(bucket_name)
+          Auth.request Config.settings[:rs_host] + '/mkbucket/' + bucket_name
+        end
+
         def stat(bucket, key)
           Auth.request Config.settings[:rs_host] + '/stat/' + encode_entry_uri(bucket, key)
         end
@@ -57,6 +65,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

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'uri'
+require 'cgi'
 require 'json'
 require 'zlib'
 require 'base64'
@@ -38,18 +39,21 @@ module Qiniu
           :accept => :json,
           :user_agent => Config.settings[:user_agent]
         }
-        if options[:signature_auth] && options[:signature_auth] == true
-          signature_token = generate_qbox_signature(Config.settings[:access_key], Config.settings[:secret_key], url, data)
-          header_options.merge!('Authorization' => "QBox #{signature_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]
-          header_options.merge!('Authorization' => "Bearer #{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
+          response = RestClient.get(url, header_options)
         when :post
           header_options.merge!(:content_type => options[:content_type])
-          response = RestClient.post url, data, header_options
+          response = RestClient.post(url, data, header_options)
         end
         code = response.respond_to?(:code) ? response.code.to_i : 0
         if code != 200
@@ -88,57 +92,38 @@ module Qiniu
         end
       end
 
-      def upload_multipart_data(url, filepath, action_string, callback_query_string = '')
-        code, data = 0, {}
-        begin
-          header_options = {
-            :accept => :json,
-            :user_agent => Config.settings[:user_agent]
-          }
+      def upload_multipart_data(url, filepath, action_string, callback_query_string = '', uptoken = nil)
           post_data = {
-            :file => File.new(filepath, 'rb'),
             :params => callback_query_string,
             :action => action_string,
+            :file => File.new(filepath, 'rb'),
             :multipart => true
           }
-          response = RestClient.post url, post_data, header_options
-          body = response.respond_to?(:body) ? response.body : ""
-          data = safe_json_parse(body) unless body.empty?
-          code = response.code.to_i if response.respond_to?(:code)
-        rescue Errno::ECONNRESET => err
-          Log.logger.error err
-        rescue => e
-          Log.logger.warn "#{e.message} => Utils.http_request('#{url}')"
-          res = e.response
-          if e.respond_to? :response
-            res = e.response
-            code = res.code.to_i if res.respond_to? :code
-            body = res.respond_to?(:body) ? res.body : ""
-            data = safe_json_parse(body) unless body.empty?
-          end
-        end
-        [code, data]
+          post_data[:auth] = uptoken unless uptoken.nil?
+          http_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 }
-        URI.escape(total_param.join("&"))
+        total_param = params.map { |key, value| %Q(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub('+', '%20')}) }
+        total_param.join("&")
       end
 
       def crc32checksum(filepath)
         File.open(filepath, "rb") { |f| Zlib.crc32 f.read }
       end
 
-      def generate_qbox_signature(access_key, secret_key, url, params)
+      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";
+        signature += "\n"
         if params.is_a?(Hash)
-            total_param = params.map { |key, value| key.to_s+"="+value.to_s }
-            signature += total_param.join("&")
+            params_string = generate_query_string(params)
+            signature += params_string
         end
         hmac = HMAC::SHA1.new(secret_key)
         hmac.update(signature)

lib/qiniu/rs/version.rb

@@ -2,6 +2,6 @@
 
 module Qiniu
   module RS
-    VERSION = "2.0.4"
+    VERSION = "3.0.2"
   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,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'cgi'
+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| %Q(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub('+', '%20')}) }
+            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,39 @@
+# -*- 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, :callback_body_type, :customer
+
+        def initialize(opts = {})
+          @scope = opts[:scope]
+          @expires_in = opts[:expires_in]
+          @callback_url = opts[:callback_url]
+          @callback_body_type = opts[:callback_body_type]
+          @customer = opts[:customer]
+        end
+
+        def generate_signature
+          params = {:scope => @scope, :deadline => Time.now.to_i + @expires_in}
+          params[:callbackUrl] = @callback_url if !@callback_url.nil? && !@callback_url.empty?
+          params[:callbackBodyType] = @callback_body_type if !@callback_body_type.nil? && !@callback_body_type.empty?
+          params[:customer] = @customer if !@customer.nil? && !@customer.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

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["why404@gmail.com"]
   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/why404/qiniu-rs"
+  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,8 +17,8 @@ Gem::Specification.new do |gem|
   gem.version       = Qiniu::RS::VERSION
 
   # specify any dependencies here; for example:
-  gem.add_development_dependency "rake", "~> 0.9.2.2"
-  gem.add_development_dependency "rspec", "~> 2.10.0"
+  gem.add_development_dependency "rake", "~> 0.9"
+  gem.add_development_dependency "rspec", "~> 2.11"
   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"

spec/qiniu/rs/auth_spec.rb

@@ -8,8 +8,8 @@ module Qiniu
     describe Auth do
 
       before :all do
-        @username = "test@qbox.net"
-        @password = "test"
+        @username = "qboxtest"
+        @password = "qboxtest123"
 
         code, data = Qiniu::RS::Auth.exchange_by_password!(@username, @password)
         code.should == 200

spec/qiniu/rs/eu_spec.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs/io'
+require 'qiniu/rs/pub'
+require 'qiniu/rs/eu'
+
+module Qiniu
+  module RS
+    describe EU do
+
+      before :all do
+        @customer_id = "awhy.xu@gmail.com"
+        @bucket = "wm_test_bucket"
+        @key = "image_logo_for_test.png"
+
+        local_file = File.expand_path('../' + @key, __FILE__)
+        upopts = {:scope => @bucket, :expires_in => 3600, :customer => @customer_id}
+        uptoken = Qiniu::RS.generate_upload_token(upopts)
+
+        code, data = Qiniu::RS::IO.upload_with_token(uptoken, local_file, @bucket, @key, nil, nil, nil, true)
+        code.should == 200
+        puts data.inspect
+
+        code2, data2 = Qiniu::RS::Pub.set_separator(@bucket, "-")
+        code2.should == 200
+        puts data2.inspect
+
+        code3, data3 = Qiniu::RS::Pub.set_style(@bucket, "small.jpg", "imageView/1/w/120/h/120/q/85/format/jpg/watermark/1")
+        code3.should == 200
+        puts data3.inspect
+      end
+
+      #after :all do
+      #  result = Qiniu::RS.drop(@bucket)
+      #  result.should_not be_false
+      #end
+
+      context ".set_watermark" do
+        it "should works" do
+          options = {
+            :text => "Powered by QiniuRS"
+          }
+          code, data = Qiniu::RS::EU.set_watermark(@customer_id, options)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".get_watermark" do
+        it "should works" do
+          code, data = Qiniu::RS::EU.get_watermark(@customer_id)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

spec/qiniu/rs/image_spec.rb

@@ -9,7 +9,7 @@ module Qiniu
   module RS
     describe Image do
 
-      before :each do
+      before :all do
 =begin
         code, data = Qiniu::RS::Auth.exchange_by_password!("test@qbox.net", "test")
         code.should == 200
@@ -20,11 +20,15 @@ module Qiniu
         puts data.inspect
 =end
 
-        @bucket = "test_images"
+        @bucket = "test_images_12345"
         @key = "image_logo_for_test.png"
 
         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
@@ -34,19 +38,46 @@ module Qiniu
                                   :key => @key,
                                   :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 => "!120x120>",
+            :gravity => "center",
+            :crop => "!120x120a0a0",
+            :quality => 85,
+            :rotate => 45,
+            :format => "jpg",
+            :auto_orient => true
+        }
       end
 
       context ".info" do
         it "should works" do
-          result = Qiniu::RS.get(@bucket, @key)
-          result["url"].should_not be_empty
-          puts result.inspect
-          code, data = Qiniu::RS::Image.info(result["url"])
+          code, data = Qiniu::RS::Image.info(@source_image_url)
           code.should == 200
           puts data.inspect
         end
       end
 
+      context ".exif" do
+        it "should works" do
+          code, data = Qiniu::RS::Image.exif(@source_image_url)
+          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

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# Utils.-*- encoding: utf-8 -*-
 
 require 'spec_helper'
 require 'qiniu/rs/auth'
@@ -19,21 +19,36 @@ module Qiniu
         data["refresh_token"].should_not be_empty
         puts data.inspect
 =end
-
-        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"]
         @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
+      end
+
+      context ".upload_with_token" do
+        it "should works" do
+          upopts = {:scope => @bucket, :expires_in => 3600, :customer => "awhy.xu@gmail.com"}
+          uptoken = Qiniu::RS.generate_upload_token(upopts)
+          code, data = Qiniu::RS::IO.upload_with_token(uptoken, __FILE__, @bucket, @key, nil, nil, nil, true)
           code.should == 200
           puts data.inspect
         end

spec/qiniu/rs/pub_spec.rb

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'qiniu/rs/auth'
+require 'qiniu/rs/rs'
+require 'qiniu/rs/pub'
+
+module Qiniu
+  module RS
+    describe Pub do
+
+      before :all do
+        @bucket = "test123"
+        code, data = Qiniu::RS::RS.mkbucket(@bucket)
+        code.should == 200
+        puts data.inspect
+      end
+
+=begin
+      context ".mkbucket" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.mkbucket(@bucket)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+=end
+
+      after :all do
+        result = Qiniu::RS.drop(@bucket)
+        result.should_not be_false
+      end
+
+      context ".set_protected" do
+        it "should works" do
+          code, data = Qiniu::RS::Pub.set_protected(@bucket, 1)
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".set_separator" do
+        it "should works" do
+          code, data = Qiniu::RS::Pub.set_separator(@bucket, "-")
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".set_style" do
+        it "should works" do
+          code, data = Qiniu::RS::Pub.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+      context ".unset_style" do
+        it "should works" do
+          code, data = Qiniu::RS::Pub.unset_style(@bucket, "small.jpg")
+          code.should == 200
+          puts data.inspect
+        end
+      end
+
+    end
+  end
+end

spec/qiniu/rs/rs_spec.rb

@@ -11,31 +11,34 @@ 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)
-        data["access_token"].should_not be_empty
-        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
-        data2["url"].should_not be_empty
-        data2["expiresIn"].should_not be_zero
-        puts data2.inspect
-
-        @put_url = data2["url"]
-        @bucket = "test"
+        @bucket = "test_bucket_1234"
         @key = Digest::SHA1.hexdigest (Time.now.to_i+rand(100)).to_s
-        @domain = 'cdn.example.com'
+        @domain = 'iovip.qbox.me/test'
+
+        code, data = Qiniu::RS::RS.mkbucket(@bucket)
+        code.should == 200
+        puts data.inspect
       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.put_auth()
+          code.should == 200
+          data["url"].should_not be_empty
+          data["expiresIn"].should_not be_zero
+          puts data.inspect
+          @put_url = data["url"]
+
+          code2, data2 = Qiniu::RS::IO.upload_file(@put_url, __FILE__, @bucket, @key)
+          code2.should == 200
+          puts data2.inspect
+        end
+      end
+
+      context ".buckets" do
+        it "should works" do
+          code, data = Qiniu::RS::RS.buckets
           code.should == 200
           puts data.inspect
         end

spec/qiniu/rs_spec.rb

@@ -10,16 +10,72 @@ 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'
+
+      result = Qiniu::RS.mkbucket(@bucket)
+      result.should_not be_false
     end
 
-=begin
-    context ".login!" do
+    context ".buckets" do
       it "should works" do
-        result = Qiniu::RS.login!("test@qbox.net", "test")
-        result.should be_true
+        result = Qiniu::RS.buckets
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".set_protected" do
+      it "should works" do
+        result = Qiniu::RS.set_protected(@bucket, 1)
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".set_separator" do
+      it "should works" do
+        result = Qiniu::RS.set_separator(@bucket, "-")
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".set_style" do
+      it "should works" do
+        result = Qiniu::RS.set_style(@bucket, "small.jpg", "imageMogr/auto-orient/thumbnail/!120x120r/gravity/center/crop/!120x120/quality/80")
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".unset_style" do
+      it "should works" do
+        result = Qiniu::RS.unset_style(@bucket, "small.jpg")
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".set_watermark" do
+      it "should works" do
+        options = {
+          :text => "Powered by QiniuRS"
+        }
+        result = Qiniu::RS.set_watermark(1, options)
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
+    context ".get_watermark" do
+      it "should works" do
+        result = Qiniu::RS.get_watermark(1)
+        result.should_not be_false
+        puts result.inspect
       end
     end
-=end
 
     context ".put_auth" do
       it "should works" do
@@ -40,11 +96,39 @@ 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 ".upload_file" do
+      it "should works" do
+        uptoken_opts = {:scope => @bucket, :expires_in => 3600}
+        upload_opts = {
+          :uptoken => Qiniu::RS.generate_upload_token(uptoken_opts),
+          :file => __FILE__,
+          :bucket => @bucket,
+          :key => @key,
+          :enable_crc32_check => true
+        }
+        result = Qiniu::RS.upload_file(upload_opts)
+        result.should_not be_false
+        puts result.inspect
+      end
+    end
+
     context ".stat" do
       it "should works" do
         result = Qiniu::RS.stat(@bucket, @key)
@@ -138,7 +222,7 @@ module Qiniu
 
     context ".image_info" do
       it "should works" do
-        data = Qiniu::RS.get("test_images", "image_logo_for_test.png")
+        data = Qiniu::RS.get(@test_image_bucket, @test_image_key)
         data.should_not be_false
         data.should_not be_empty
         puts data.inspect
@@ -149,5 +233,53 @@ module Qiniu
       end
     end
 
+    context ".image_exif" 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
+        result = Qiniu::RS.image_exif(data["url"])
+        puts result.inspect
+      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"
+        result = Qiniu::RS.mkbucket(dest_bucket)
+        result.should_not be_false
+
+        dest_key = "cropped-" + @test_image_key
+        src_img_url = data["url"]
+        mogrify_options = {
+          :thumbnail => "!120x120>",
+          :gravity => "center",
+          :crop => "!120x120a0a0",
+          :quality => 85,
+          :rotate => 45,
+          :format => "jpg",
+          :auto_orient => true
+        }
+        result2 = Qiniu::RS.image_mogrify_save_as(dest_bucket, dest_key, src_img_url, mogrify_options)
+        result2.should_not be_false
+        result2.should_not be_empty
+        puts result2.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,19 @@ require 'rspec'
 
 RSpec.configure do |config|
   config.before :all do
+#=begin
     Qiniu::RS.establish_connection! :access_key => "3fPHl_SLkPXdioqI_A8_NGngPWVJhlDk2ktRjogH",
-                                    :secret_key => "bXTPMDJrVYRJUiSDRFtFYwycVD_mjXxYWrCYlDHy"
+                                    :secret_key => "bXTPMDJrVYRJUiSDRFtFYwycVD_mjXxYWrCYlDHy",
+#=end
+=begin
+    Qiniu::RS.establish_connection! :access_key => "bE21M6FW9V7zAFrBY5psgKOKJQLiBj12qMWTpc57",
+                                    :secret_key => "uMo7Nyq_eDK_CuQ8_FYCxoTHQZqjiaPh-cbiKO7L",
+                                    :auth_url   => "http://m1.qbox.me:13001/oauth2/token",
+                                    :rs_host    => "http://m1.qbox.me:13003",
+                                    :io_host    => "http://m1.qbox.me:13004",
+                                    :up_host    => "http://m1.qbox.me:13019",
+                                    :pub_host   => "http://m1.qbox.me:13012",
+                                    :eu_host    => "http://m1.qbox.me:13050"
+=end
   end
 end