fix(version-up): check-in of latest sources

This also includes crate files to remember which
crates we have published already.

Related to #44

gen/taskqueue1_beta2/Cargo.toml

@@ -4,7 +4,7 @@
 [package]
 
 name = "google-taskqueue1_beta2"
-version = "0.1.1+20141111"
+version = "0.1.2+20141111"
 authors = ["Sebastian Thiel <byronimo@gmail>"]
 description = "A complete library to interact with taskqueue (protocol v1beta2)"
 repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/taskqueue1_beta2"
@@ -16,7 +16,7 @@ keywords = ["taskqueue", "google", "protocol", "web", "api"]
 [dependencies]
 hyper = "*"
 mime = "*"
+yup-oauth2 = "*"
 url = "*"
 serde = "*"
 serde_macros = "*"
-yup-oauth2 = "*"

gen/taskqueue1_beta2/README.md

@@ -1,11 +1,11 @@
 <!---
 DO NOT EDIT !
-This file was generated automatically from 'src/mako/README.md.mako'
+This file was generated automatically from 'src/mako/api/README.md.mako'
 DO NOT EDIT !
 -->
 The `google-taskqueue1_beta2` library allows access to all features of the *Google taskqueue* service.
 
-This documentation was generated from *taskqueue* crate version *0.1.1+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.1*.
+This documentation was generated from *taskqueue* crate version *0.1.2+20141111*, where *20141111* is the exact revision of the *taskqueue:v1beta2* schema built by the [mako](http://www.makotemplates.org/) code generator *v0.1.2*.
 
 Everything else about the *taskqueue* *v1_beta2* API can be found at the
 [official documentation site](https://developers.google.com/appengine/docs/python/taskqueue/rest).
@@ -27,6 +27,8 @@ The API is structured into the following primary items:
 
 * **[Hub](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/struct.Taskqueue.html)**
     * a central object to maintain state and allow accessing all *Activities*
+    * creates [*Method Builders*](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.MethodsBuilder.html) which in turn
+      allow access to individual [*Call Builders*](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.CallBuilder.html)
 * **[Resources](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.Resource.html)**
     * primary types that you can apply *Activities* to
     * a collection of properties and *Parts*
@@ -36,6 +38,8 @@ The API is structured into the following primary items:
 * **[Activities](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.CallBuilder.html)**
     * operations to apply to *Resources*
 
+All *structures* are marked with applicable traits to further categorize them and ease browsing.
+
 Generally speaking, you can invoke *Activities* like this:
 
 ```Rust,ignore
@@ -76,7 +80,7 @@ google-taskqueue1_beta2 = "*"
 extern crate hyper;
 extern crate "yup-oauth2" as oauth2;
 extern crate "google-taskqueue1_beta2" as taskqueue1_beta2;
-use taskqueue1_beta2::Result;
+use taskqueue1_beta2::{Result, Error};
 use std::default::Default;
 use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
 use taskqueue1_beta2::Taskqueue;
@@ -102,15 +106,17 @@ let result = hub.tasks().lease("project", "taskqueue", -65, -42)
              .doit();
 
 match result {
-    Result::HttpError(err) => println!("HTTPERROR: {:?}", err),
-    Result::MissingAPIKey => println!("Auth: Missing API Key - used if there are no scopes"),
-    Result::MissingToken => println!("OAuth2: Missing Token"),
-    Result::Cancelled => println!("Operation cancelled by user"),
-    Result::UploadSizeLimitExceeded(size, max_size) => println!("Upload size too big: {} of {}", size, max_size),
-    Result::Failure(_) => println!("General Failure (hyper::client::Response doesn't print)"),
-    Result::FieldClash(clashed_field) => println!("You added custom parameter which is part of builder: {:?}", clashed_field),
-    Result::JsonDecodeError(err) => println!("Couldn't understand server reply - maybe API needs update: {:?}", err),
-    Result::Success(_) => println!("Success (value doesn't print)"),
+    Err(e) => match e {
+        Error::HttpError(err) => println!("HTTPERROR: {:?}", err),
+        Error::MissingAPIKey => println!("Auth: Missing API Key - used if there are no scopes"),
+        Error::MissingToken => println!("OAuth2: Missing Token"),
+        Error::Cancelled => println!("Operation canceled by user"),
+        Error::UploadSizeLimitExceeded(size, max_size) => println!("Upload size too big: {} of {}", size, max_size),
+        Error::Failure(_) => println!("General Failure (hyper::client::Response doesn't print)"),
+        Error::FieldClash(clashed_field) => println!("You added custom parameter which is part of builder: {:?}", clashed_field),
+        Error::JsonDecodeError(err) => println!("Couldn't understand server reply - maybe API needs update: {:?}", err),
+    },
+    Ok(_) => println!("Success (value doesn't print)"),
 }
 
 ```
@@ -123,7 +129,7 @@ the doit() methods, or handed as possibly intermediate results to either the
 When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This 
 makes the system potentially resilient to all kinds of errors.
 
-## Uploads and Downlods
+## Uploads and Downloads
 If a method supports downloads, the response body, which is part of the [Result](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/enum.Result.html), should be
 read by you to obtain the media.
 If such a method also supports a [Response Result](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.ResponseResult.html), it will return that by default.
@@ -146,8 +152,9 @@ The [delegate trait](http://byron.github.io/google-apis-rs/google-taskqueue1_bet
 ## Optional Parts in Server-Requests
 
 All structures provided by this library are made to be [enocodable](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.RequestValue.html) and 
-[decodable](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.ResponseResult.html) via json. Optionals are used to indicate that partial requests are responses are valid.
-Most optionals are are considered [Parts](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.Part.html) which are identifyable by name, which will be sent to 
+[decodable](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.ResponseResult.html) via *json*. Optionals are used to indicate that partial requests are responses 
+are valid.
+Most optionals are are considered [Parts](http://byron.github.io/google-apis-rs/google-taskqueue1_beta2/trait.Part.html) which are identifiable by name, which will be sent to 
 the server to indicate either the set parts of the request or the desired parts in the response.
 
 ## Builder Arguments

gen/taskqueue1_beta2/src/cmn.rs

@@ -1,4 +1,4 @@
-// COPY OF 'src/rust/cmn.rs'
+// COPY OF 'src/rust/api/cmn.rs'
 // DO NOT EDIT
 use std::marker::MarkerTrait;
 use std::io::{self, Read, Seek, Cursor, Write, SeekFrom};
@@ -24,7 +24,7 @@ use serde;
 pub trait Hub: MarkerTrait {}
 
 /// Identifies types for building methods of a particular resource type
-pub trait ResourceMethodsBuilder: MarkerTrait {}
+pub trait MethodsBuilder: MarkerTrait {}
 
 /// Identifies types which represent builders for a particular resource method
 pub trait CallBuilder: MarkerTrait {}
@@ -105,12 +105,15 @@ pub trait Delegate {
     /// information if he is interesting in knowing more context when further calls to it
     /// are made.
     /// The matching `finished()` call will always be made, no matter whether or not the API
-    /// request was sucessfull. That way, the delgate may easily maintain a clean state 
+    /// request was successful. That way, the delegate may easily maintain a clean state 
     /// between various API calls.
     fn begin(&mut self, MethodInfo) {}
 
     /// Called whenever there is an [HttpError](http://hyperium.github.io/hyper/hyper/error/enum.HttpError.html), usually if there are network problems.
     /// 
+    /// If you choose to retry after a duration, the duration should be chosen using the
+    /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff).
+    ///
     /// Return retry information.
     fn http_error(&mut self, &hyper::HttpError) -> Retry {
         Retry::Abort
@@ -133,7 +136,7 @@ pub trait Delegate {
     /// Called during resumable uploads to provide a URL for the impending upload.
     /// It was saved after a previous call to `store_upload_url(...)`, and if not None,
     /// will be used instead of asking the server for a new upload URL.
-    /// This is useful in case a previous resumable upload was aborted/cancelled, but should now
+    /// This is useful in case a previous resumable upload was aborted/canceled, but should now
     /// be resumed.
     /// The returned URL will be used exactly once - if it fails again and the delegate allows
     /// to retry, we will ask the server for a new upload URL.
@@ -154,8 +157,8 @@ pub trait Delegate {
     /// 
     /// # Arguments
     ///
-    /// `json_encoded_value` - The json-encoded value which failed to decode.
-    /// `json_decode_error` - The decoder error
+    /// * `json_encoded_value` - The json-encoded value which failed to decode.
+    /// * `json_decode_error`  - The decoder error
     fn response_json_decode_error(&mut self, json_encoded_value: &str, json_decode_error: &serde::json::Error) {
         let _ = json_encoded_value;
         let _ = json_decode_error;
@@ -166,6 +169,9 @@ pub trait Delegate {
     /// depends on the used API method.
     /// The delegate should check the status, header and decoded json error to decide
     /// whether to retry or not. In the latter case, the underlying call will fail.
+    ///
+    /// If you choose to retry after a duration, the duration should be chosen using the
+    /// [exponential backoff algorithm](http://en.wikipedia.org/wiki/Exponential_backoff).
     fn http_failure(&mut self, _: &hyper::client::Response, Option<JsonServerError>) -> Retry {
         Retry::Abort
     }
@@ -197,8 +203,8 @@ pub trait Delegate {
     ///
     /// # Arguments
     /// 
-    /// `is_success` - a true value indicates the operation was successful. If false, you should
-    ///                discard all values stored during `store_upload_url`.
+    /// * `is_success` - a true value indicates the operation was successful. If false, you should
+    ///                  discard all values stored during `store_upload_url`.
     fn finished(&mut self, is_success: bool) {
         let _ = is_success;
     }
@@ -212,8 +218,8 @@ pub struct DefaultDelegate;
 impl Delegate for DefaultDelegate {}
 
 
-/// A universal result type used as return for all action method results.
-pub enum Result<T = ()> {
+
+pub enum Error {
     /// The http connection failed
     HttpError(hyper::HttpError),
 
@@ -240,11 +246,11 @@ pub enum Result<T = ()> {
 
     /// Indicates an HTTP repsonse with a non-success status code
     Failure(hyper::client::Response),
-
-    /// It worked !
-    Success(T),
 }
 
+/// A universal result type used as return for all calls.
+pub type Result<T> = std::result::Result<T, Error>;
+
 /// Contains information about an API request.
 pub struct MethodInfo {
     pub id: &'static str,
@@ -499,7 +505,7 @@ impl<'a, NC, A> ResumableUploadHelper<'a, NC, A>
     where NC: hyper::net::NetworkConnector,
           A: oauth2::GetToken {
 
-    fn query_transfer_status(&mut self) -> (Option<u64>, hyper::HttpResult<hyper::client::Response>) {
+    fn query_transfer_status(&mut self) -> std::result::Result<u64, hyper::HttpResult<hyper::client::Response>> {
         loop {
             match self.client.post(self.url)
                 .header(UserAgent(self.user_agent.to_string()))
@@ -516,17 +522,17 @@ impl<'a, NC, A> ResumableUploadHelper<'a, NC, A>
                                 sleep(d);
                                 continue;
                             }
-                            return (None, Ok(r))
+                            return Err(Ok(r))
                         }
                     };
-                    return (Some(h.0.last), Ok(r))
+                    return Ok(h.0.last)
                 }
                 Err(err) => {
                     if let Retry::After(d) = self.delegate.http_error(&err) {
                         sleep(d);
                         continue;
                     }
-                    return (None, Err(err))
+                    return Err(Err(err))
                 }
             }
         }
@@ -539,8 +545,8 @@ impl<'a, NC, A> ResumableUploadHelper<'a, NC, A>
         let mut start = match self.start_at {
             Some(s) => s,
             None => match self.query_transfer_status() {
-                (Some(s), _) => s,
-                (_, result) => return Some(result)
+                Ok(s) => s,
+                Err(result) => return Some(result)
             }
         };