Merge pull request #12 from why404/develop

add up, pub, eu and rsplus supported

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qiniu-rs (2.3.0)
+    qiniu-rs (3.0.1)
       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)

docs/README.md

@@ -4,7 +4,7 @@ title: Ruby SDK 使用指南 | 七牛云存储
 
 # Ruby SDK 使用指南
 
-此 Ruby SDK 适用于 Ruby 1.8.x, 1.9.x, jruby, rbx, ree 版本，基于 [七牛云存储官方API](/v2/api/) 构建。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云存储上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构的服务或应用，通过七牛云存储及其 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)
 
@@ -15,25 +15,38 @@ title: Ruby SDK 使用指南 | 七牛云存储
     - [应用接入](#establish_connection!)
     - [Ruby On Rails 应用初始化设置](#ror-init)
     - [上传文件](#upload)
-        - [服务端上传流程](#upload-server-side)
-        - [客户端上传流程](#upload-client-side)
-            - [获取用于上传文件的临时授权URL](#put_auth)
+        - [获取用于上传文件的临时授权凭证](#generate-upload-token)
+        - [服务端上传文件](#upload-server-side)
+            - [针对 NotFound 场景处理](#upload-file-for-not-found)
+        - [客户端直传文件](#upload-client-side)
     - [查看文件属性信息](#stat)
     - [获取文件下载链接（含文件属性信息）](#get)
     - [只获取文件下载链接](#download)
     - [删除指定文件](#delete)
-    - [删除所有文件（单个“表”）](#drop)
+    - [删除所有文件（单个 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)
@@ -94,21 +107,61 @@ title: Ruby SDK 使用指南 | 七牛云存储
 
 ### 上传文件
 
-<a name="upload-server-side"></a>
+<a name="generate-upload-token"></a>
 
-#### 服务端上传流程
+#### 获取用于上传文件的临时授权凭证
 
-通过 `Qiniu::RS.put_file()` 方法可在客户方的业务服务器上直接往七牛云存储上传文件。该函数规格如下：
+要上传一个文件，首先需要调用 SDK 提供的 `Qiniu::RS.generate_upload_token` 函数来获取一个经过授权用于临时匿名上传的 `upload_token`——经过数字签名的一组数据信息，该 `upload_token` 作为文件上传流中 `multipart/form-data` 的一部分进行传输。
 
-    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
+`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），本地文件可被读取的有效路径
 
@@ -122,48 +175,46 @@ title: Ruby SDK 使用指南 | 七牛云存储
 : 可选，字符串类型（String），文件的 mime-type 值。如若不传入，SDK 会自行计算得出，若计算失败缺省使用 application/octet-stream 代替之。
 
 :note
-: 可选，字符串类型（String），备注信息。
+: 可选，字符串类型（String），为文件添加备注信息。
+
+:callback_params
+: 可选，String 或者 Hash 类型，文件上传成功后，七牛云存储向客户方业务服务器发送的回调参数。
 
 :enable_crc32_check
-: 可选，Boolean 类型，是否启用文件上传 crc32 校验，默认为 false 。
+: 可选，Boolean 类型，是否启用文件上传 crc32 校验，缺省为 false 。
 
 **返回值**
 
-上传成功，返回 `true`，否则返回 `false` 。
+上传成功，返回如下一个 Hash，否则返回 `false`：
 
-**针对 NotFound 处理**
+    {"hash"=>"FgHk-_iqpnZji6PsNr4ghsK5qEwR"}
 
-您可以上传一个应对 HTTP 404 出错处理的文件，当您 [创建公开外链](#publish) 后，若公开的外链找不到该文件，即可使用您上传的“自定义404文件”代替之。要这么做，您只须使用 `Qiniu::RS.put_file` 函数上传一个 `key` 为固定字符串类型的值 `errno-404` 即可。
+<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>
 
-#### 客户端上传流程
+#### 客户端直传文件
 
-<a name="put_auth"></a>
+客户端上传流程和服务端上传类似，差别在于：客户端直传文件所需的 `upload_token` 可以选择在客户方的业务服务器端生成，也可以选择在客户方的客户端程序里边生成。选择前者，可以和客户方的业务揉合得更紧密和安全些，比如防伪造请求。
 
-#### 获取用于上传文件的临时授权URL
+简单来讲，客户端上传流程也分为两步：
 
-    Qiniu::RS.put_auth(expires_in = nil, callback_url = nil)
+1. 获取 `upload_token`（[用于上传文件的临时授权凭证](#generate-upload-token)）
+2. 将该 `upload_token` 作为文件上传流 `multipart/form-data` 中的一部分实现上传操作
 
-要上传一个文件，首先需要调用 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` 这个地址，假设该地址是您业务服务器用于接收处理回调信息的地址。
+如果您的网络程序是从云端（服务端程序）到终端（手持设备应用）的架构模型，且终端用户有使用您移动端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>
@@ -287,7 +338,7 @@ key
 
 <a name="drop"></a>
 
-### 删除所有文件（单个“表”）
+### 删除所有文件（单个 bucket）
 
     Qiniu::RS.drop(bucket)
 
@@ -411,7 +462,7 @@ keys
 
 调用 `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` 。
+这样，用户就可以通过 `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` 访问。
 
@@ -444,6 +495,64 @@ domain
 
 如果撤销成功，返回 `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>
 
 ### 图像处理
@@ -484,6 +593,24 @@ 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>
 
 #### 获取指定规格的缩略图预览地址
@@ -498,13 +625,14 @@ 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的缩略图）
+: 可选，字符串或整型的枚举值，指定缩略图的具体规格，参考 [七牛云存储API之缩略图预览](/v3/api/foimg/#fo-imagePreview) 和 [自定义缩略图规格](/v3/api/foimg/#fo-imagePreviewEx) 。该值缺省为 0 （即输出宽800px高600px图片质量为85的缩略图）
 
 **返回值**
 
 返回一个字符串类型的缩略图 URL
 
 
+
 <a name="image_mogrify_preview_url"></a>
 
 #### 高级图像处理（缩略、裁剪、旋转、转化）
@@ -533,7 +661,7 @@ mogrify_options
         :auto_orient => <TrueOrFalse>
     }
 
-`Qiniu::RS.image_mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](#/v2/api/foimg/#fo-imageMogr)。
+`Qiniu::RS.image_mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](/v3/api/foimg/#fo-imageMogr)。
 
 **返回值**
 
@@ -574,7 +702,7 @@ mogrify_options
         :auto_orient => <TrueOrFalse>
     }
 
-`Qiniu::RS::Image.mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](#/v2/api/foimg/#fo-imageMogr)。
+`Qiniu::RS::Image.mogrify_preview_url()` 方法是对七牛云存储图像处理高级接口的完整包装，关于 `mogrify_options` 参数里边的具体含义和使用方式，可以参考文档：[图像处理高级接口](/v3/api/foimg/#fo-imageMogr)。
 
 **返回值**
 
@@ -613,6 +741,227 @@ mogrify_options
     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>
 
 ## 贡献代码

lib/qiniu/rs.rb

@@ -11,6 +11,8 @@ 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'
@@ -29,6 +31,46 @@ 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
@@ -56,6 +98,18 @@ module Qiniu
         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
@@ -124,6 +178,11 @@ 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
@@ -137,10 +196,6 @@ module Qiniu
         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]
@@ -148,7 +203,8 @@ module Qiniu
         #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.callback_body_type = opts[:callback_body_type]
+        #token_obj.customer = opts[:customer]
         token_obj.generate_token
       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, {:qbox_signature_token => generate_qbox_signature(url, data)}
+        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

@@ -22,6 +22,9 @@ module Qiniu
           :auth_url        => "https://acc.qbox.me/oauth2/token",
           :rs_host         => "http://rs.qbox.me:10100",
           :io_host         => "http://iovip.qbox.me",
+          :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,6 +10,10 @@ 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
@@ -29,7 +33,7 @@ module Qiniu
             params_string += %Q(/#{key}/#{opts[key]}) unless opts[key].nil?
           end
           params_string += '/auto-orient' unless opts["auto_orient"].nil?
-          'imageMogr' + params_string
+          'imageMogr' + URI.escape(params_string)
         end
 
       end

lib/qiniu/rs/io.rb

@@ -30,9 +30,16 @@ module Qiniu
         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
+          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

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

lib/qiniu/rs/utils.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'uri'
+require 'cgi'
 require 'json'
 require 'zlib'
 require 'base64'
@@ -49,10 +50,10 @@ module Qiniu
         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
@@ -91,55 +92,21 @@ module Qiniu
         end
       end
 
-      def send_multipart_request(url, post_data, options = {})
-        code, data = 0, {}
-        begin
-          header_options = {
-            :accept => :json,
-            :user_agent => Config.settings[:user_agent]
-          }
-          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?
-          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]
-      end
-
-      def upload_multipart_data(url, filepath, action_string, callback_query_string = '')
+      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
           }
-          send_multipart_request(url, post_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)
@@ -153,10 +120,10 @@ module Qiniu
         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)
@@ -164,21 +131,6 @@ module Qiniu
         %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 = "2.3.0"
+    VERSION = "3.0.1"
   end
 end

lib/qiniu/tokens/qbox_token.rb

@@ -1,5 +1,6 @@
 # -*- encoding: utf-8 -*-
 
+require 'cgi'
 require 'json'
 require 'qiniu/tokens/access_token'
 
@@ -21,7 +22,7 @@ module Qiniu
           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 }
+            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

lib/qiniu/tokens/upload_token.rb

@@ -10,19 +10,21 @@ module Qiniu
 
         include Utils
 
-        attr_accessor :scope, :expires_in, :callback_url, :return_url
+        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]
-          @return_url = opts[:return_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? && !@calback_url.empty?
-          params[:returnUrl] = @return_url if !@return_url.nil? && !@return_url.empty?
+          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
 

qiniu-rs.gemspec

@@ -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

@@ -36,7 +36,6 @@ module Qiniu
                                   :file => local_file,
                                   :bucket => @bucket,
                                   :key => @key,
-                                  :mime_type => "image/png",
                                   :enable_crc32_check => true
         result.should be_true
 
@@ -47,7 +46,7 @@ module Qiniu
         @source_image_url = result["url"]
 
         @mogrify_options = {
-            :thumbnail => "!120x120r",
+            :thumbnail => "!120x120>",
             :gravity => "center",
             :crop => "!120x120a0a0",
             :quality => 85,
@@ -65,6 +64,13 @@ module Qiniu
         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)

spec/qiniu/rs/io_spec.rb

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# Utils.-*- encoding: utf-8 -*-
 
 require 'spec_helper'
 require 'qiniu/rs/auth'
@@ -44,6 +44,16 @@ module Qiniu
         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
+      end
+
     end
   end
 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.upload_file" do
         it "should works" do
-          code, data = Qiniu::RS::IO.upload_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

@@ -13,6 +13,9 @@ module Qiniu
 
       @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
@@ -24,6 +27,65 @@ module Qiniu
     end
 =end
 
+    context ".buckets" do
+      it "should works" do
+        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
+
     context ".put_auth" do
       it "should works" do
         result = Qiniu::RS.put_auth(10)
@@ -60,6 +122,22 @@ module Qiniu
       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)
@@ -164,6 +242,17 @@ 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)
@@ -172,10 +261,13 @@ module Qiniu
         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 => "!120x120r",
+          :thumbnail => "!120x120>",
           :gravity => "center",
           :crop => "!120x120a0a0",
           :quality => 85,
@@ -183,10 +275,10 @@ module Qiniu
           :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
+        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
 

spec/spec_helper.rb

@@ -6,7 +6,20 @@ 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",
+                                    :pub_host   => "http://183.136.128.84:10202"
+#=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