fix(all): update all code to latest version

* add new APIs
* remove old ones
* add latest json files

gen/dns1-cli/Cargo.toml

@@ -0,0 +1,31 @@
+# DO NOT EDIT !
+# This file was generated automatically from 'src/mako/Cargo.toml.mako'
+# DO NOT EDIT !
+[package]
+
+name = "google-dns1-cli"
+version = "0.0.1+20150218"
+authors = ["Sebastian Thiel <byronimo@gmail.com>"]
+description = "A complete library to interact with dns (protocol v1)"
+repository = "https://github.com/Byron/google-apis-rs/tree/master/gen/dns1-cli"
+homepage = "https://developers.google.com/cloud-dns"
+documentation = "http://byron.github.io/google-apis-rs/google_dns1_cli"
+license = "MIT"
+keywords = ["dns", "google", "cli"]
+
+[[bin]]
+name = "dns1"
+
+[dependencies]
+hyper = "*"
+mime = "*"
+yup-oauth2 = "*"
+docopt = "*"
+docopt_macros = "*"
+rustc-serialize = "*"
+yup-hyper-mock = "*"
+serde = ">= 0.3.0"
+serde_macros = "*"
+
+[dependencies.google-dns1]
+path = "../dns1"

gen/dns1-cli/LICENSE.md

@@ -0,0 +1,30 @@
+<!---
+DO NOT EDIT !
+This file was generated automatically from 'src/mako/LICENSE.md.mako'
+DO NOT EDIT !
+-->
+The MIT License (MIT)
+=====================
+
+Copyright © `2015` `Sebastian Thiel`
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

gen/dns1-cli/README.md

@@ -0,0 +1,4 @@
+# HELLO DNS:V1
+
+
+Include information about application secret files, and how we automatically write a default one.

gen/dns1-cli/mkdocs.yml

@@ -0,0 +1,25 @@
+site_name: dns v0.0.1+20150218
+site_url: http://byron.github.io/google-apis-rs/google-dns1-cli
+site_description: Write integrating applications with bcore
+
+repo_url: https://github.com/Byron/google-apis-rs/tree/master/gen/dns1-cli
+
+docs_dir: docs
+site_dir: build_html
+
+pages:
+- ['index.md', 'Home']
+- ['changes_create.md', 'Changes', 'Create']
+- ['changes_get.md', 'Changes', 'Get']
+- ['changes_list.md', 'Changes', 'List']
+- ['managed-zones_create.md', 'Managed Zones', 'Create']
+- ['managed-zones_delete.md', 'Managed Zones', 'Delete']
+- ['managed-zones_get.md', 'Managed Zones', 'Get']
+- ['managed-zones_list.md', 'Managed Zones', 'List']
+- ['projects_get.md', 'Projects', 'Get']
+- ['resource-record-sets_list.md', 'Resource Record Sets', 'List']
+
+theme: readthedocs
+
+copyright: Copyright © 2015, `Sebastian Thiel`
+

gen/dns1-cli/src/cmn.rs

@@ -0,0 +1,454 @@
+// COPY OF 'src/rust/cli/cmn.rs'
+// DO NOT EDIT
+use oauth2::{ApplicationSecret, ConsoleApplicationSecret, TokenStorage, Token};
+use rustc_serialize::json;
+use mime::Mime;
+
+use std::fs;
+use std::env;
+use std::io;
+use std::fmt;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+use std::string::ToString;
+use std::io::{Write, Read, stdout};
+
+use std::default::Default;
+
+const FIELD_SEP: char = '.';
+
+#[derive(Clone, Default)]
+pub struct FieldCursor(Vec<String>);
+
+impl ToString for  FieldCursor {
+    fn to_string(&self) -> String {
+        self.0.connect(".")
+    }
+}
+
+impl FieldCursor {
+    pub fn set(&mut self, value: &str) -> Result<(), CLIError> {
+        if value.len() == 0 {
+            return Err(CLIError::Field(FieldError::Empty))
+        }
+
+        let mut first_is_field_sep = false;
+        let mut char_count: usize = 0;
+        let mut last_c = FIELD_SEP;
+        let mut num_conscutive_field_seps = 0;
+
+        let mut field = String::new();
+        let mut fields = self.0.clone();
+
+        let push_field = |fs: &mut Vec<String>, f: &mut String| {
+            if f.len() > 0 {
+                fs.push(f.clone());
+                f.truncate(0);
+            }
+        };
+
+        for (cid, c) in value.chars().enumerate() {
+            char_count += 1;
+
+            if c == FIELD_SEP {
+                if cid == 0 {
+                    first_is_field_sep = true;
+                }
+                num_conscutive_field_seps += 1;
+                if cid > 0 && last_c == FIELD_SEP {
+                    if fields.pop().is_none() {
+                        return Err(CLIError::Field(FieldError::PopOnEmpty(value.to_string())))
+                    }
+                } else {
+                    push_field(&mut fields, &mut field);
+                }
+            } else {
+                num_conscutive_field_seps = 0;
+                if cid == 1 {
+                    if first_is_field_sep {
+                        fields.truncate(0);
+                    }
+                }
+                field.push(c);
+            }
+
+            last_c = c;
+        }
+
+        push_field(&mut fields, &mut field);
+
+        if char_count == 1 && first_is_field_sep {
+            fields.truncate(0);
+        }
+        if char_count > 1 && num_conscutive_field_seps == 1 {
+            return Err(CLIError::Field(FieldError::TrailingFieldSep(value.to_string())))
+        }
+
+        self.0 = fields;
+        Ok(())
+    }
+
+    pub fn num_fields(&self) -> usize {
+        self.0.len()
+    }
+}
+
+pub fn parse_kv_arg<'a>(kv: &'a str, err: &mut InvalidOptionsError, for_hashmap: bool)
+                                                        -> (&'a str, Option<&'a str>) {
+    let mut add_err = || err.issues.push(CLIError::InvalidKeyValueSyntax(kv.to_string(),for_hashmap));
+    match kv.find('=') {
+        None => {
+            add_err();
+            return (kv, None)
+        },
+        Some(pos) => {
+            let key = &kv[..pos];
+            if kv.len() <= pos + 1 {
+                add_err();
+                return (key, None)
+            }
+            (key, Some(&kv[pos+1..]))
+        }
+    }
+}
+
+pub fn input_file_from_opts(file_path: &str, err: &mut InvalidOptionsError) -> Option<fs::File> {
+    match fs::File::open(file_path) {
+        Ok(f) => Some(f),
+        Err(io_err) => {
+            err.issues.push(CLIError::Input(InputError::IOError((file_path.to_string(), io_err))));
+            None
+        }
+    }
+}
+
+pub fn input_mime_from_opts(mime: &str, err: &mut InvalidOptionsError) -> Option<Mime> {
+    match mime.parse() {
+        Ok(m) => Some(m),
+        Err(_) => {
+            err.issues.push(CLIError::Input(InputError::Mime(mime.to_string())));
+            None
+        }
+    }
+}
+
+// May panic if we can't open the file - this is anticipated, we can't currently communicate this 
+// kind of error: TODO: fix this architecture :)
+pub fn writer_from_opts(flag: bool, arg: &str) -> Box<Write> {
+    if !flag || arg == "-" {
+        Box::new(stdout())
+    } else {
+        Box::new(fs::OpenOptions::new().create(true).write(true).open(arg).unwrap())
+    }
+}
+
+
+pub fn arg_from_str<T>(arg: &str, err: &mut InvalidOptionsError, 
+                                  arg_name: &'static str, 
+                                  arg_type: &'static str) -> T
+                                                        where   T: FromStr + Default,
+                                                             <T as FromStr>::Err: fmt::Display {
+    match FromStr::from_str(arg) {
+        Err(perr) => {
+            err.issues.push(
+                CLIError::ParseError((arg_name, arg_type, arg.to_string(), format!("{}", perr)))
+            );
+            Default::default()
+        },
+        Ok(v) => v,
+    }
+}
+
+pub struct JsonTokenStorage {
+    pub program_name: &'static str,
+    pub db_dir: String,
+}
+
+impl JsonTokenStorage {
+    fn path(&self, scope_hash: u64) -> PathBuf {
+        Path::new(&self.db_dir).join(&format!("{}-token-{}.json", self.program_name, scope_hash))
+    }
+}
+
+impl TokenStorage for JsonTokenStorage {
+    type Error = io::Error;
+
+    // NOTE: logging might be interesting, currently we swallow all errors
+    fn set(&mut self, scope_hash: u64, _: &Vec<&str>, token: Option<Token>) -> Option<io::Error> {
+        match token {
+            None => {
+                match fs::remove_file(self.path(scope_hash)) {
+                    Err(err) => 
+                        match err.kind() {
+                            io::ErrorKind::NotFound => None,
+                            _ => Some(err)
+                        },
+                    Ok(_) => None
+                }
+            }
+            Some(token) => {
+                let json_token = json::encode(&token).unwrap();
+                match fs::OpenOptions::new().create(true).write(true).open(&self.path(scope_hash)) {
+                    Ok(mut f) => {
+                        match f.write(json_token.as_bytes()) {
+                            Ok(_) => None,
+                            Err(io_err) => Some(io_err),
+                        }
+                    },
+                    Err(io_err) => Some(io_err)
+                }
+            }
+        }
+    }
+
+    fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result<Option<Token>, io::Error> {
+        match fs::File::open(&self.path(scope_hash)) {
+            Ok(mut f) => {
+                let mut json_string = String::new();
+                match f.read_to_string(&mut json_string) {
+                    Ok(_) => Ok(Some(json::decode::<Token>(&json_string).unwrap())),
+                    Err(io_err) => Err(io_err),
+                }
+            },
+            Err(io_err) => {
+                match io_err.kind() {
+                    io::ErrorKind::NotFound => Ok(None),
+                    _ => Err(io_err)
+                }
+            }
+        }
+    }
+}
+
+
+#[derive(Debug)]
+pub enum ApplicationSecretError {
+    DecoderError((String, json::DecoderError)),
+    FormatError(String),    
+}
+
+impl fmt::Display for ApplicationSecretError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            ApplicationSecretError::DecoderError((ref path, ref err))
+                => writeln!(f, "Could not decode file at '{}' with error: {}", 
+                            path, err),
+            ApplicationSecretError::FormatError(ref path)
+                => writeln!(f, "'installed' field is unset in secret file at '{}'", 
+                            path),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum ConfigurationError {
+    DirectoryCreationFailed((String, io::Error)),
+    DirectoryUnset,
+    HomeExpansionFailed(String),
+    Secret(ApplicationSecretError),
+    IOError((String, io::Error)),
+}
+
+impl fmt::Display for ConfigurationError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            ConfigurationError::DirectoryCreationFailed((ref dir, ref err))
+                => writeln!(f, "Directory '{}' could not be created with error: {}", dir, err),
+            ConfigurationError::DirectoryUnset 
+                => writeln!(f, "--config-dir was unset or empty"),
+            ConfigurationError::HomeExpansionFailed(ref dir)
+                => writeln!(f, "Couldn't find HOME directory of current user, failed to expand '{}'", dir),
+            ConfigurationError::Secret(ref err)
+                => writeln!(f, "Secret -> {}", err),
+            ConfigurationError::IOError((ref path, ref err))
+                => writeln!(f, "IO operation failed on path '{}' with error: {}", path, err),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum InputError {
+    IOError((String, io::Error)),
+    Mime(String),
+}
+
+impl fmt::Display for InputError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            InputError::IOError((ref file_path, ref io_err))
+                => writeln!(f, "Failed to open '{}' for reading with error: {}", file_path, io_err),
+            InputError::Mime(ref mime)
+                => writeln!(f, "'{}' is not a known mime-type", mime),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum FieldError {
+    PopOnEmpty(String),
+    TrailingFieldSep(String),
+    Unknown(String),
+    Empty,
+}
+
+
+impl fmt::Display for FieldError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            FieldError::PopOnEmpty(ref field)
+                => writeln!(f, "'{}': Cannot move up on empty field cursor", field),
+            FieldError::TrailingFieldSep(ref field)
+                => writeln!(f, "'{}': Single field separator may not be last character", field),
+            FieldError::Unknown(ref field)
+                => writeln!(f, "Field '{}' does not exist", field),
+            FieldError::Empty
+                => writeln!(f, "Field names must not be empty"),
+        }
+    }
+}
+
+
+#[derive(Debug)]
+pub enum CLIError {
+    Configuration(ConfigurationError),
+    ParseError((&'static str, &'static str, String, String)),
+    UnknownParameter(String),
+    InvalidKeyValueSyntax(String, bool),
+    Input(InputError),
+    Field(FieldError),
+}
+
+impl fmt::Display for CLIError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            CLIError::Configuration(ref err) => write!(f, "Configuration -> {}", err),
+            CLIError::Input(ref err) => write!(f, "Input -> {}", err),
+            CLIError::Field(ref err) => write!(f, "Field -> {}", err),
+            CLIError::ParseError((arg_name, type_name, ref value, ref err_desc)) 
+                => writeln!(f, "Failed to parse argument '{}' with value '{}' as {} with error: {}",
+                            arg_name, value, type_name, err_desc),
+            CLIError::UnknownParameter(ref param_name) 
+                => writeln!(f, "Parameter '{}' is unknown.", param_name),
+            CLIError::InvalidKeyValueSyntax(ref kv, is_hashmap) => {
+                let hashmap_info = if is_hashmap { "hashmap " } else { "" };
+                writeln!(f, "'{}' does not match {}pattern <key>=<value>", kv, hashmap_info)
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct InvalidOptionsError {
+    pub issues: Vec<CLIError>,
+    pub exit_code: i32,
+}
+
+impl fmt::Display for InvalidOptionsError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        for issue in &self.issues {
+            try!(issue.fmt(f));
+        }
+        Ok(())
+    }
+}
+
+impl InvalidOptionsError {
+    pub fn single(err: CLIError, exit_code: i32) -> InvalidOptionsError {
+        InvalidOptionsError {
+            issues: vec![err],
+            exit_code: exit_code,
+        }
+    }
+
+    pub fn new() -> InvalidOptionsError {
+        InvalidOptionsError {
+            issues: Vec::new(),
+            exit_code: 1,
+        }
+    }
+}
+
+pub fn assure_config_dir_exists(dir: &str) -> Result<String, CLIError> {
+    let trdir = dir.trim();
+    if trdir.len() == 0 {
+        return Err(CLIError::Configuration(ConfigurationError::DirectoryUnset))
+    }
+
+    let expanded_config_dir = 
+        if trdir.as_bytes()[0] == b'~' {
+            match env::var("HOME").ok().or(env::var("UserProfile").ok()) {
+                None => return Err(CLIError::Configuration(ConfigurationError::HomeExpansionFailed(trdir.to_string()))),
+                Some(mut user) => {
+                    user.push_str(&trdir[1..]);
+                    user
+                }
+            }
+        } else {
+            trdir.to_string()
+        };
+
+    if let Err(err) = fs::create_dir(&expanded_config_dir) {
+        if err.kind() != io::ErrorKind::AlreadyExists {
+            return Err(CLIError::Configuration(
+                    ConfigurationError::DirectoryCreationFailed((expanded_config_dir, err))))
+        }
+    }
+
+    Ok(expanded_config_dir)
+}
+
+pub fn application_secret_from_directory(dir: &str, 
+                                         secret_basename: &str, 
+                                         json_app_secret: &str)
+                                                        -> Result<ApplicationSecret, CLIError> {
+    let secret_path = Path::new(dir).join(secret_basename);
+    let secret_str = || secret_path.as_path().to_str().unwrap().to_string();
+    let secret_io_error = |io_err: io::Error| {
+            Err(CLIError::Configuration(ConfigurationError::IOError(
+                (secret_str(), io_err)
+            )))
+    };
+
+    for _ in 0..2 {
+        match fs::File::open(&secret_path) {
+            Err(mut err) => {
+                if err.kind() == io::ErrorKind::NotFound {
+                    // Write our built-in one - user may adjust the written file at will
+
+                    err = match fs::OpenOptions::new().create(true).write(true).open(&secret_path) {
+                        Err(cfe) => cfe,
+                        Ok(mut f) => {
+                            match f.write(json_app_secret.as_bytes()) {
+                                Err(io_err) => io_err,
+                                Ok(_) => continue,
+                            }
+                        }
+                    };
+                    // fall through to IO error handling
+                }
+                return secret_io_error(err)
+            },
+            Ok(mut f) => {
+                let mut json_encoded_secret = String::new();
+                if let Err(io_err) = f.read_to_string(&mut json_encoded_secret) {
+                    return secret_io_error(io_err)
+                }
+                match json::decode::<ConsoleApplicationSecret>(&json_encoded_secret) {
+                    Err(json_decode_error) => return Err(CLIError::Configuration(
+                        ConfigurationError::Secret(ApplicationSecretError::DecoderError(
+                                                (secret_str(), json_decode_error)
+                                              )))),
+                    Ok(console_secret) => match console_secret.installed {
+                        Some(secret) => return Ok(secret),
+                        None => return Err(
+                                    CLIError::Configuration(
+                                    ConfigurationError::Secret(
+                                    ApplicationSecretError::FormatError(secret_str())
+                                    )))
+                    },
+                }
+            }
+        }
+    }
+    unreachable!();
+}

gen/dns1-cli/src/main.rs

@@ -0,0 +1,674 @@
+// DO NOT EDIT !
+// This file was generated automatically from 'src/mako/cli/main.rs.mako'
+// DO NOT EDIT !
+#![feature(plugin, exit_status)]
+#![plugin(docopt_macros)]
+#![allow(unused_variables, unused_imports, dead_code, unused_mut)]
+
+extern crate docopt;
+extern crate yup_oauth2 as oauth2;
+extern crate yup_hyper_mock as mock;
+extern crate rustc_serialize;
+extern crate serde;
+extern crate hyper;
+extern crate mime;
+extern crate google_dns1 as api;
+
+use std::env;
+use std::io::{self, Write};
+
+docopt!(Options derive Debug, "
+Usage: 
+  dns1 [options] changes create <project> <managed-zone> -r <kv>... [-p <v>]... [-o <out>]
+  dns1 [options] changes get <project> <managed-zone> <change-id> [-p <v>]... [-o <out>]
+  dns1 [options] changes list <project> <managed-zone> [-p <v>]... [-o <out>]
+  dns1 [options] managed-zones create <project> -r <kv>... [-p <v>]... [-o <out>]
+  dns1 [options] managed-zones delete <project> <managed-zone> [-p <v>]...
+  dns1 [options] managed-zones get <project> <managed-zone> [-p <v>]... [-o <out>]
+  dns1 [options] managed-zones list <project> [-p <v>]... [-o <out>]
+  dns1 [options] projects get <project> [-p <v>]... [-o <out>]
+  dns1 [options] resource-record-sets list <project> <managed-zone> [-p <v>]... [-o <out>]
+  dns1 --help
+
+All documentation details can be found TODO: <URL to github.io docs here, see #51>
+
+Configuration:
+  --scope <url>  
+            Specify the authentication a method should be executed in. Each scope requires
+            the user to grant this application permission to use it.
+            If unset, it defaults to the shortest scope url for a particular method.
+  --config-dir <folder>
+            A directory into which we will store our persistent data. Defaults to a user-writable
+            directory that we will create during the first invocation.
+            [default: ~/.google-service-cli]
+  --debug
+            Output all server communication to standard error. `tx` and `rx` are placed into 
+            the same stream.
+  --debug-auth
+            Output all communication related to authentication to standard error. `tx` and `rx` are placed into 
+            the same stream.
+");
+
+mod cmn;
+use cmn::{InvalidOptionsError, CLIError, JsonTokenStorage, arg_from_str, writer_from_opts, parse_kv_arg, 
+          input_file_from_opts, input_mime_from_opts, FieldCursor, FieldError};
+
+use std::default::Default;
+use std::str::FromStr;
+
+use oauth2::{Authenticator, DefaultAuthenticatorDelegate};
+use rustc_serialize::json;
+
+struct Engine {
+    opt: Options,
+    hub: api::Dns<hyper::Client, Authenticator<DefaultAuthenticatorDelegate, JsonTokenStorage, hyper::Client>>,
+}
+
+
+impl Engine {
+    fn _changes_create(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut request = api::Change::default();
+        let mut call = self.hub.changes().create(&request, &self.opt.arg_project, &self.opt.arg_managed_zone);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        
+        let mut field_name = FieldCursor::default();
+        for kvarg in self.opt.arg_kv.iter() {
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            if let Err(field_err) = field_name.set(&*key) {
+                err.issues.push(field_err);
+            }
+            match &field_name.to_string()[..] {
+                "status" => {
+                        request.status = Some(value.unwrap_or("").to_string());
+                    },
+                "kind" => {
+                        request.kind = Some(value.unwrap_or("").to_string());
+                    },
+                "id" => {
+                        request.id = Some(value.unwrap_or("").to_string());
+                    },
+                "start-time" => {
+                        request.start_time = Some(value.unwrap_or("").to_string());
+                    },
+                _ => {
+                    err.issues.push(CLIError::Field(FieldError::Unknown(field_name.to_string())));
+                }
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _changes_get(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.changes().get(&self.opt.arg_project, &self.opt.arg_managed_zone, &self.opt.arg_change_id);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _changes_list(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.changes().list(&self.opt.arg_project, &self.opt.arg_managed_zone);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "sort-order" => {
+                    call = call.sort_order(value.unwrap_or(""));
+                },
+                "sort-by" => {
+                    call = call.sort_by(value.unwrap_or(""));
+                },
+                "page-token" => {
+                    call = call.page_token(value.unwrap_or(""));
+                },
+                "max-results" => {
+                    call = call.max_results(arg_from_str(value.unwrap_or("-0"), err, "max-results", "integer"));
+                },
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _managed_zones_create(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut request = api::ManagedZone::default();
+        let mut call = self.hub.managed_zones().create(&request, &self.opt.arg_project);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        
+        let mut field_name = FieldCursor::default();
+        for kvarg in self.opt.arg_kv.iter() {
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            if let Err(field_err) = field_name.set(&*key) {
+                err.issues.push(field_err);
+            }
+            match &field_name.to_string()[..] {
+                "kind" => {
+                        request.kind = Some(value.unwrap_or("").to_string());
+                    },
+                "description" => {
+                        request.description = Some(value.unwrap_or("").to_string());
+                    },
+                "name-servers" => {
+                        if request.name_servers.is_none() {
+                           request.name_servers = Some(Default::default());
+                        }
+                                        request.name_servers.as_mut().unwrap().push(value.unwrap_or("").to_string());
+                    },
+                "creation-time" => {
+                        request.creation_time = Some(value.unwrap_or("").to_string());
+                    },
+                "name-server-set" => {
+                        request.name_server_set = Some(value.unwrap_or("").to_string());
+                    },
+                "dns-name" => {
+                        request.dns_name = Some(value.unwrap_or("").to_string());
+                    },
+                "id" => {
+                        request.id = Some(value.unwrap_or("").to_string());
+                    },
+                "name" => {
+                        request.name = Some(value.unwrap_or("").to_string());
+                    },
+                _ => {
+                    err.issues.push(CLIError::Field(FieldError::Unknown(field_name.to_string())));
+                }
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _managed_zones_delete(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.managed_zones().delete(&self.opt.arg_project, &self.opt.arg_managed_zone);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok(mut response) => {
+                    None
+                }
+            }
+        }
+    }
+
+    fn _managed_zones_get(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.managed_zones().get(&self.opt.arg_project, &self.opt.arg_managed_zone);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _managed_zones_list(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.managed_zones().list(&self.opt.arg_project);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "page-token" => {
+                    call = call.page_token(value.unwrap_or(""));
+                },
+                "max-results" => {
+                    call = call.max_results(arg_from_str(value.unwrap_or("-0"), err, "max-results", "integer"));
+                },
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _projects_get(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.projects().get(&self.opt.arg_project);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _resource_record_sets_list(&self, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Option<api::Error> {
+        let mut call = self.hub.resource_record_sets().list(&self.opt.arg_project, &self.opt.arg_managed_zone);
+        for parg in self.opt.arg_v.iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                "type" => {
+                    call = call.type_(value.unwrap_or(""));
+                },
+                "page-token" => {
+                    call = call.page_token(value.unwrap_or(""));
+                },
+                "name" => {
+                    call = call.name(value.unwrap_or(""));
+                },
+                "max-results" => {
+                    call = call.max_results(arg_from_str(value.unwrap_or("-0"), err, "max-results", "integer"));
+                },
+                "alt"
+                |"fields"
+                |"key"
+                |"oauth-token"
+                |"pretty-print"
+                |"quota-user"
+                |"user-ip" => {
+                    let map = [
+                        ("oauth-token", "oauth_token"),
+                        ("pretty-print", "prettyPrint"),
+                        ("quota-user", "quotaUser"),
+                        ("user-ip", "userIp"),
+                    ];
+                    call = call.param(map.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"))
+                },
+                _ => err.issues.push(CLIError::UnknownParameter(key.to_string())),
+            }
+        }
+        let protocol = "standard-request";
+        if dry_run {
+            None
+        } else {
+            assert!(err.issues.len() == 0);
+            let mut ostream = writer_from_opts(self.opt.flag_o, &self.opt.arg_out);
+            match match protocol {
+                "standard-request" => call.doit(),
+                _ => unreachable!(),
+            } {
+                Err(api_err) => Some(api_err),
+                Ok((mut response, output_schema)) => {
+                    serde::json::to_writer_pretty(&mut ostream, &output_schema).unwrap();
+                    None
+                }
+            }
+        }
+    }
+
+    fn _doit(&self, dry_run: bool) -> (Option<api::Error>, Option<InvalidOptionsError>) {
+        let mut err = InvalidOptionsError::new();
+        let mut call_result: Option<api::Error>;
+        let mut err_opt: Option<InvalidOptionsError> = None;
+
+        if self.opt.cmd_changes {
+            if self.opt.cmd_create {
+                call_result = self._changes_create(dry_run, &mut err);
+            } else if self.opt.cmd_get {
+                call_result = self._changes_get(dry_run, &mut err);
+            } else if self.opt.cmd_list {
+                call_result = self._changes_list(dry_run, &mut err);
+            } else {
+                unreachable!();
+            }
+        }
+ else if self.opt.cmd_managed_zones {
+            if self.opt.cmd_create {
+                call_result = self._managed_zones_create(dry_run, &mut err);
+            } else if self.opt.cmd_delete {
+                call_result = self._managed_zones_delete(dry_run, &mut err);
+            } else if self.opt.cmd_get {
+                call_result = self._managed_zones_get(dry_run, &mut err);
+            } else if self.opt.cmd_list {
+                call_result = self._managed_zones_list(dry_run, &mut err);
+            } else {
+                unreachable!();
+            }
+        }
+ else if self.opt.cmd_projects {
+            if self.opt.cmd_get {
+                call_result = self._projects_get(dry_run, &mut err);
+            } else {
+                unreachable!();
+            }
+        }
+ else if self.opt.cmd_resource_record_sets {
+            if self.opt.cmd_list {
+                call_result = self._resource_record_sets_list(dry_run, &mut err);
+            } else {
+                unreachable!();
+            }
+        } else {
+            unreachable!();
+        }
+
+        if dry_run {
+            if err.issues.len() > 0 {
+                err_opt = Some(err);
+            }
+        }
+        (call_result, err_opt)
+    }
+
+    // Please note that this call will fail if any part of the opt can't be handled
+    fn new(opt: Options) -> Result<Engine, InvalidOptionsError> {
+        let (config_dir, secret) = {
+            let config_dir = match cmn::assure_config_dir_exists(&opt.flag_config_dir) {
+                Err(e) => return Err(InvalidOptionsError::single(e, 3)),
+                Ok(p) => p,
+            };
+
+            match cmn::application_secret_from_directory(&config_dir, "dns1-secret.json", 
+                                                         "{\"installed\":{\"auth_uri\":\"https://accounts.google.com/o/oauth2/auth\",\"client_secret\":\"hCsslbCUyfehWMmbkG8vTYxG\",\"token_uri\":\"https://accounts.google.com/o/oauth2/token\",\"client_email\":\"\",\"redirect_uris\":[\"urn:ietf:wg:oauth:2.0:oob\",\"oob\"],\"client_x509_cert_url\":\"\",\"client_id\":\"620010449518-9ngf7o4dhs0dka470npqvor6dc5lqb9b.apps.googleusercontent.com\",\"auth_provider_x509_cert_url\":\"https://www.googleapis.com/oauth2/v1/certs\"}}") {
+                Ok(secret) => (config_dir, secret),
+                Err(e) => return Err(InvalidOptionsError::single(e, 4))
+            }
+        };
+
+        let auth = Authenticator::new(  &secret, DefaultAuthenticatorDelegate,
+                                        if opt.flag_debug_auth {
+                                            hyper::Client::with_connector(mock::TeeConnector {
+                                                    connector: hyper::net::HttpConnector(None) 
+                                                })
+                                        } else {
+                                            hyper::Client::new()
+                                        },
+                                        JsonTokenStorage {
+                                          program_name: "dns1",
+                                          db_dir: config_dir.clone(),
+                                        }, None);
+
+        let client = 
+            if opt.flag_debug {
+                hyper::Client::with_connector(mock::TeeConnector {
+                        connector: hyper::net::HttpConnector(None) 
+                    })
+            } else {
+                hyper::Client::new()
+            };
+        let engine = Engine {
+            opt: opt,
+            hub: api::Dns::new(client, auth),
+        };
+
+        match engine._doit(true) {
+            (_, Some(err)) => Err(err),
+            _ => Ok(engine),
+        }
+    }
+
+    // Execute the call with all the bells and whistles, informing the caller only if there was an error.
+    // The absense of one indicates success.
+    fn doit(&self) -> Option<api::Error> {
+        self._doit(false).0
+    }
+}
+
+fn main() {
+    let opts: Options = Options::docopt().decode().unwrap_or_else(|e| e.exit());
+    match Engine::new(opts) {
+        Err(err) => {
+            writeln!(io::stderr(), "{}", err).ok();
+            env::set_exit_status(err.exit_code);
+        },
+        Ok(engine) => {
+            if let Some(err) = engine.doit() {
+                writeln!(io::stderr(), "{:?}", err).ok();
+                writeln!(io::stderr(), "{}", err).ok();
+                env::set_exit_status(1);
+            }
+        }
+    }
+}