chore(gen): adds all missing apis

With recent changes in the generator and or rust a bunch of api are now
working that were blacklisted. This commit adds the generated files for
those apis.

gen/language1-cli/src/cmn.rs

@@ -0,0 +1,799 @@
+// COPY OF 'src/rust/cli/cmn.rs'
+// DO NOT EDIT
+use oauth2::{ApplicationSecret, ConsoleApplicationSecret, TokenStorage, Token};
+use serde_json as json;
+use serde_json::value::Value;
+use mime::Mime;
+use clap::{App, SubCommand};
+use strsim;
+
+use std::fs;
+use std::env;
+use std::io;
+use std::error::Error as StdError;
+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 = '.';
+
+
+pub enum ComplexType {
+    Pod,
+    Vec,
+    Map,
+}
+
+// Null,
+// Bool(bool),
+// I64(i64),
+// U64(u64),
+// F64(f64),
+// String(String),
+
+pub enum JsonType {
+    Boolean,
+    Int,
+    Uint,
+    Float,
+    String,
+}
+
+pub struct JsonTypeInfo {
+    pub jtype: JsonType,
+    pub ctype: ComplexType,
+}
+
+// Based on @erickt user comment. Thanks for the idea !
+// Remove all keys whose values are null from given value (changed in place)
+pub fn remove_json_null_values(value: &mut Value) {
+    match *value {
+        Value::Object(ref mut map) => {
+            let mut for_removal = Vec::new();
+
+            for (key, mut value) in map.iter_mut() {
+                if value.is_null() {
+                    for_removal.push(key.clone());
+                } else {
+                    remove_json_null_values(&mut value);
+                }
+            }
+
+            for key in &for_removal {
+                map.remove(key);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn did_you_mean<'a>(v: &str, possible_values: &[&'a str]) -> Option<&'a str> {
+
+    let mut candidate: Option<(f64, &str)> = None;
+    for pv in possible_values {
+        let confidence = strsim::jaro_winkler(v, pv);
+        if confidence > 0.8 &&
+           (candidate.is_none() || (candidate.as_ref().unwrap().0 < confidence)) {
+            candidate = Some((confidence, pv));
+        }
+    }
+    match candidate {
+        None => None,
+        Some((_, candidate)) => Some(candidate),
+    }
+}
+
+pub enum CallType {
+    Upload(UploadProtocol),
+    Standard,
+}
+
+arg_enum!{
+    pub enum UploadProtocol {
+        Simple,
+        Resumable
+    }
+}
+
+impl AsRef<str> for UploadProtocol {
+    fn as_ref(&self) -> &str {
+        match *self {
+            UploadProtocol::Simple => "simple",
+            UploadProtocol::Resumable => "resumable",
+        }
+    }
+}
+
+impl AsRef<str> for CallType {
+    fn as_ref(&self) -> &str {
+        match *self {
+            CallType::Upload(ref proto) => proto.as_ref(),
+            CallType::Standard => "standard-request",
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct FieldCursor(Vec<String>);
+
+impl ToString for  FieldCursor {
+    fn to_string(&self) -> String {
+        self.0.join(".")
+    }
+}
+
+impl From<&'static str> for FieldCursor {
+    fn from(value: &'static str) -> FieldCursor {
+        let mut res = FieldCursor::default();
+        res.set(value).unwrap();
+        res
+    }
+}
+
+fn assure_entry<'a, 'b>(m: &'a mut json::Map<String, Value>, k: &'b String) -> &'a mut Value {
+    if m.contains_key(k) {
+        return m.get_mut(k).expect("value to exist");
+    }
+    m.insert(k.to_owned(), Value::Object(Default::default()));
+    m.get_mut(k).expect("value to exist")
+}
+
+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 did_you_mean(value: &str, possible_values: &[&str]) -> Option<String> {
+        if value.len() == 0 {
+            return None;
+        }
+
+        let mut last_c = FIELD_SEP;
+
+        let mut field = String::new();
+        let mut output = String::new();
+
+        let push_field = |fs: &mut String, f: &mut String| {
+            if f.len() > 0 {
+                fs.push_str(match did_you_mean(&f, possible_values) {
+                    Some(candidate) => candidate,
+                    None => &f,
+                });
+                f.truncate(0);
+            }
+        };
+
+        for (cid, c) in value.chars().enumerate() {
+            if c == FIELD_SEP {
+                if last_c != FIELD_SEP {
+                    push_field(&mut output, &mut field);
+                }
+                output.push(c);
+            } else {
+                field.push(c);
+            }
+
+            last_c = c;
+        }
+
+        push_field(&mut output, &mut field);
+
+        if &output == value {
+            None
+        } else {
+            Some(output)
+        }
+    }
+
+    pub fn set_json_value(&self,
+                          mut object: &mut Value,
+                          value: &str,
+                          type_info: JsonTypeInfo,
+                          err: &mut InvalidOptionsError,
+                          orig_cursor: &FieldCursor) {
+        assert!(self.0.len() > 0);
+
+        for field in &self.0[..self.0.len() - 1] {
+            let tmp = object;
+            object = match *tmp {
+                Value::Object(ref mut mapping) => {
+                    assure_entry(mapping, &field)
+                }
+                _ => panic!("We don't expect non-object Values here ..."),
+            };
+        }
+
+        match *object {
+            Value::Object(ref mut mapping) => {
+                let field = &self.0[self.0.len() - 1];
+                let to_jval = |value: &str,
+                               jtype: JsonType,
+                               err: &mut InvalidOptionsError|
+                               -> Value {
+                    match jtype {
+                        JsonType::Boolean =>
+                            Value::Bool(arg_from_str(value, err, &field, "boolean")),
+                        JsonType::Int =>
+                            Value::Number(json::Number::from_f64(arg_from_str(value,
+                                                                              err,
+                                                                              &field,
+                                                                              "int"))
+                                              .expect("valid f64")),
+                        JsonType::Uint =>
+                            Value::Number(json::Number::from_f64(arg_from_str(value,
+                                                                              err,
+                                                                              &field,
+                                                                              "uint"))
+                                              .expect("valid f64")),
+                        JsonType::Float =>
+                            Value::Number(json::Number::from_f64(arg_from_str(value,
+                                                                              err,
+                                                                              &field,
+                                                                              "float"))
+                                              .expect("valid f64")),
+                        JsonType::String => Value::String(value.to_owned()),
+                    }
+                };
+
+                match type_info.ctype {
+                    ComplexType::Pod => {
+                        if mapping.insert(field.to_owned(), to_jval(value, type_info.jtype, err))
+                                  .is_some() {
+                            err.issues.push(CLIError::Field(FieldError::Duplicate(orig_cursor.to_string())));
+                        }
+                    }
+                    ComplexType::Vec => {
+                        match *assure_entry(mapping, field) {
+                            Value::Array(ref mut values) =>
+                                values.push(to_jval(value, type_info.jtype, err)),
+                            _ => unreachable!(),
+                        }
+                    }
+                    ComplexType::Map => {
+                        let (key, value) = parse_kv_arg(value, err, true);
+                        let jval = to_jval(value.unwrap_or(""), type_info.jtype, err);
+
+                        match *assure_entry(mapping, &field) {
+
+                            Value::Object(ref mut value_map) => {
+                                if value_map.insert(key.to_owned(), jval).is_some() {
+                                    err.issues.push(CLIError::Field(FieldError::Duplicate(orig_cursor.to_string())));
+                                }
+                            }
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    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, Some(""));
+            }
+            (key, Some(&kv[pos + 1..]))
+        }
+    }
+}
+
+pub fn calltype_from_str(name: &str,
+                         valid_protocols: Vec<String>,
+                         err: &mut InvalidOptionsError)
+                         -> CallType {
+    CallType::Upload(match UploadProtocol::from_str(name) {
+        Ok(up) => up,
+        Err(msg) => {
+            err.issues.push(CLIError::InvalidUploadProtocol(name.to_string(), valid_protocols));
+            UploadProtocol::Simple
+        }
+    })
+}
+
+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::Io((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
+        }
+    }
+}
+
+pub fn writer_from_opts(arg: Option<&str>) -> Result<Box<Write>, io::Error> {
+    let f = arg.unwrap_or("-");
+    match f {
+        "-" => Ok(Box::new(stdout())),
+        _ => match fs::OpenOptions::new().create(true).write(true).open(f) {
+            Ok(f) => Ok(Box::new(f)),
+            Err(io_err) => Err(io_err),
+        },
+    }
+}
+
+
+pub fn arg_from_str<'a, T>(arg: &str,
+                           err: &mut InvalidOptionsError,
+                           arg_name: &'a str,
+                           arg_type: &'a 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.to_owned(),
+                                                 arg_type.to_owned(),
+                                                 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))
+    }
+}
+
+
+#[derive(Debug)]
+pub enum TokenStorageError {
+    Json(json::Error),
+    Io(io::Error),
+}
+
+impl fmt::Display for TokenStorageError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            TokenStorageError::Json(ref err) => writeln!(f, "Could not serialize secrets: {}", err),
+            TokenStorageError::Io(ref err) => writeln!(f, "Failed to write secret token: {}", err),
+        }
+    }
+}
+
+impl StdError for TokenStorageError {
+    fn description(&self) -> &str {
+        "Failure when getting or setting the token storage"
+    }
+}
+
+
+impl TokenStorage for JsonTokenStorage {
+    type Error = TokenStorageError;
+
+    // NOTE: logging might be interesting, currently we swallow all errors
+    fn set(&mut self,
+           scope_hash: u64,
+           _: &Vec<&str>,
+           token: Option<Token>)
+           -> Result<(), TokenStorageError> {
+        match token {
+            None => {
+                match fs::remove_file(self.path(scope_hash)) {
+                    Err(err) => match err.kind() {
+                        io::ErrorKind::NotFound => Ok(()),
+                        _ => Err(TokenStorageError::Io(err)),
+                    },
+                    Ok(_) => Ok(()),
+                }
+            }
+            Some(token) => {
+                match fs::OpenOptions::new().create(true).write(true).open(&self.path(scope_hash)) {
+                    Ok(mut f) => {
+                        match json::to_writer_pretty(&mut f, &token) {
+                            Ok(_) => Ok(()),
+                            Err(serde_err) => Err(TokenStorageError::Json(serde_err)),
+                        }
+                    }
+                    Err(io_err) => Err(TokenStorageError::Io(io_err)),
+                }
+            }
+        }
+    }
+
+    fn get(&self, scope_hash: u64, _: &Vec<&str>) -> Result<Option<Token>, TokenStorageError> {
+        match fs::File::open(&self.path(scope_hash)) {
+            Ok(f) => {
+                match json::de::from_reader(f) {
+                    Ok(token) => Ok(Some(token)),
+                    Err(err) => Err(TokenStorageError::Json(err)),
+                }
+            }
+            Err(io_err) => {
+                match io_err.kind() {
+                    io::ErrorKind::NotFound => Ok(None),
+                    _ => Err(TokenStorageError::Io(io_err)),
+                }
+            }
+        }
+    }
+}
+
+
+#[derive(Debug)]
+pub enum ApplicationSecretError {
+    DecoderError((String, json::Error)),
+    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),
+    Io((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::Io((ref path, ref err)) =>
+                writeln!(f,
+                         "IO operation failed on path '{}' with error: {}.",
+                         path,
+                         err),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum InputError {
+    Io((String, io::Error)),
+    Mime(String),
+}
+
+impl fmt::Display for InputError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            InputError::Io((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, Option<String>, Option<String>),
+    Duplicate(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, ref suggestion, ref value) => {
+                let suffix = match *suggestion {
+                    Some(ref s) => {
+                        let kv = match *value {
+                            Some(ref v) => format!("{}={}", s, v),
+                            None => s.clone(),
+                        };
+                        format!(" Did you mean '{}' ?", kv)
+                    }
+                    None => String::new(),
+                };
+                writeln!(f, "Field '{}' does not exist.{}", field, suffix)
+            }
+            FieldError::Duplicate(ref cursor) =>
+                writeln!(f, "Value at '{}' was already set", cursor),
+            FieldError::Empty => writeln!(f, "Field names must not be empty."),
+        }
+    }
+}
+
+
+#[derive(Debug)]
+pub enum CLIError {
+    Configuration(ConfigurationError),
+    ParseError(String, String, String, String),
+    UnknownParameter(String, Vec<&'static str>),
+    InvalidUploadProtocol(String, Vec<String>),
+    InvalidKeyValueSyntax(String, bool),
+    Input(InputError),
+    Field(FieldError),
+    MissingCommandError,
+    MissingMethodError(String),
+}
+
+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::InvalidUploadProtocol(ref proto_name, ref valid_names) =>
+                writeln!(f,
+                         "'{}' is not a valid upload protocol. Choose from one of {}.",
+                         proto_name,
+                         valid_names.join(", ")),
+            CLIError::ParseError(ref arg_name, ref 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, ref possible_values) => {
+                let suffix = match did_you_mean(param_name, &possible_values) {
+                    Some(v) => format!(" Did you mean '{}' ?", v),
+                    None => String::new(),
+                };
+                write!(f, "Parameter '{}' is unknown.{}\n", param_name, suffix)
+            }
+            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)
+            }
+            CLIError::MissingCommandError => writeln!(f, "Please specify the main sub-command."),
+            CLIError::MissingMethodError(ref cmd) =>
+                writeln!(f,
+                         "Please specify the method to call on the '{}' command.",
+                         cmd),
+        }
+    }
+}
+
+#[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_console_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::Io((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) => {
+                            // Assure we convert 'ugly' json string into pretty one
+                            let console_secret: ConsoleApplicationSecret =
+                                json::from_str(json_console_secret).unwrap();
+                            match json::to_writer_pretty(&mut f, &console_secret) {
+                                Err(serde_err) =>
+                                    panic!("Unexpected serde error: {:#?}", serde_err),
+                                Ok(_) => continue,
+                            }
+                        }
+                    };
+                    // fall through to IO error handling
+                }
+                return secret_io_error(err);
+            }
+            Ok(f) => {
+                match json::de::from_reader::<_, ConsoleApplicationSecret>(f) {
+                    Err(json_err) =>
+                        return Err(CLIError::Configuration(
+                            ConfigurationError::Secret(
+                                ApplicationSecretError::DecoderError(
+                                                (secret_str(), json_err)
+                                              )))),
+                    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/language1-cli/src/main.rs

@@ -0,0 +1,942 @@
+// DO NOT EDIT !
+// This file was generated automatically from 'src/mako/cli/main.rs.mako'
+// DO NOT EDIT !
+#![allow(unused_variables, unused_imports, dead_code, unused_mut)]
+
+#[macro_use]
+extern crate clap;
+extern crate yup_oauth2 as oauth2;
+extern crate yup_hyper_mock as mock;
+extern crate hyper_rustls;
+extern crate serde;
+extern crate serde_json;
+extern crate hyper;
+extern crate mime;
+extern crate strsim;
+extern crate google_language1 as api;
+
+use std::env;
+use std::io::{self, Write};
+use clap::{App, SubCommand, Arg};
+
+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, CallType, UploadProtocol,
+          calltype_from_str, remove_json_null_values, ComplexType, JsonType, JsonTypeInfo};
+
+use std::default::Default;
+use std::str::FromStr;
+
+use oauth2::{Authenticator, DefaultAuthenticatorDelegate, FlowType};
+use serde_json as json;
+use clap::ArgMatches;
+
+enum DoitError {
+    IoError(String, io::Error),
+    ApiError(api::Error),
+}
+
+struct Engine<'n> {
+    opt: ArgMatches<'n>,
+    hub: api::CloudNaturalLanguage<hyper::Client, Authenticator<DefaultAuthenticatorDelegate, JsonTokenStorage, hyper::Client>>,
+    gp: Vec<&'static str>,
+    gpm: Vec<(&'static str, &'static str)>,
+}
+
+
+impl<'n> Engine<'n> {
+    fn _documents_analyze_entities(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "encoding-type" => Some(("encodingType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["content", "document", "encoding-type", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::AnalyzeEntitiesRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().analyze_entities(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _documents_analyze_entity_sentiment(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "encoding-type" => Some(("encodingType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["content", "document", "encoding-type", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::AnalyzeEntitySentimentRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().analyze_entity_sentiment(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _documents_analyze_sentiment(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "encoding-type" => Some(("encodingType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["content", "document", "encoding-type", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::AnalyzeSentimentRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().analyze_sentiment(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _documents_analyze_syntax(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "encoding-type" => Some(("encodingType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["content", "document", "encoding-type", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::AnalyzeSyntaxRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().analyze_syntax(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _documents_annotate_text(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "encoding-type" => Some(("encodingType", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "features.extract-document-sentiment" => Some(("features.extractDocumentSentiment", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })),
+                    "features.extract-entity-sentiment" => Some(("features.extractEntitySentiment", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })),
+                    "features.extract-entities" => Some(("features.extractEntities", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })),
+                    "features.extract-syntax" => Some(("features.extractSyntax", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })),
+                    "features.classify-text" => Some(("features.classifyText", JsonTypeInfo { jtype: JsonType::Boolean, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["classify-text", "content", "document", "encoding-type", "extract-document-sentiment", "extract-entities", "extract-entity-sentiment", "extract-syntax", "features", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::AnnotateTextRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().annotate_text(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _documents_classify_text(&self, opt: &ArgMatches<'n>, dry_run: bool, err: &mut InvalidOptionsError)
+                                                    -> Result<(), DoitError> {
+        
+        let mut field_cursor = FieldCursor::default();
+        let mut object = json::value::Value::Object(Default::default());
+        
+        for kvarg in opt.values_of("kv").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let last_errc = err.issues.len();
+            let (key, value) = parse_kv_arg(&*kvarg, err, false);
+            let mut temp_cursor = field_cursor.clone();
+            if let Err(field_err) = temp_cursor.set(&*key) {
+                err.issues.push(field_err);
+            }
+            if value.is_none() {
+                field_cursor = temp_cursor.clone();
+                if err.issues.len() > last_errc {
+                    err.issues.remove(last_errc);
+                }
+                continue;
+            }
+        
+            let type_info: Option<(&'static str, JsonTypeInfo)> =
+                match &temp_cursor.to_string()[..] {
+                    "document.content" => Some(("document.content", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.type" => Some(("document.type", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.language" => Some(("document.language", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    "document.gcs-content-uri" => Some(("document.gcsContentUri", JsonTypeInfo { jtype: JsonType::String, ctype: ComplexType::Pod })),
+                    _ => {
+                        let suggestion = FieldCursor::did_you_mean(key, &vec!["content", "document", "gcs-content-uri", "language", "type"]);
+                        err.issues.push(CLIError::Field(FieldError::Unknown(temp_cursor.to_string(), suggestion, value.map(|v| v.to_string()))));
+                        None
+                    }
+                };
+            if let Some((field_cursor_str, type_info)) = type_info {
+                FieldCursor::from(field_cursor_str).set_json_value(&mut object, value.unwrap(), type_info, err, &temp_cursor);
+            }
+        }
+        let mut request: api::ClassifyTextRequest = json::value::from_value(object).unwrap();
+        let mut call = self.hub.documents().classify_text(request);
+        for parg in opt.values_of("v").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+            let (key, value) = parse_kv_arg(&*parg, err, false);
+            match key {
+                _ => {
+                    let mut found = false;
+                    for param in &self.gp {
+                        if key == *param {
+                            found = true;
+                            call = call.param(self.gpm.iter().find(|t| t.0 == key).unwrap_or(&("", key)).1, value.unwrap_or("unset"));
+                            break;
+                        }
+                    }
+                    if !found {
+                        err.issues.push(CLIError::UnknownParameter(key.to_string(),
+                                                                  {let mut v = Vec::new();
+                                                                           v.extend(self.gp.iter().map(|v|*v));
+                                                                           v } ));
+                    }
+                }
+            }
+        }
+        let protocol = CallType::Standard;
+        if dry_run {
+            Ok(())
+        } else {
+            assert!(err.issues.len() == 0);
+            for scope in self.opt.values_of("url").map(|i|i.collect()).unwrap_or(Vec::new()).iter() {
+                call = call.add_scope(scope);
+            }
+            let mut ostream = match writer_from_opts(opt.value_of("out")) {
+                Ok(mut f) => f,
+                Err(io_err) => return Err(DoitError::IoError(opt.value_of("out").unwrap_or("-").to_string(), io_err)),
+            };
+            match match protocol {
+                CallType::Standard => call.doit(),
+                _ => unreachable!()
+            } {
+                Err(api_err) => Err(DoitError::ApiError(api_err)),
+                Ok((mut response, output_schema)) => {
+                    let mut value = json::value::to_value(&output_schema).expect("serde to work");
+                    remove_json_null_values(&mut value);
+                    json::to_writer_pretty(&mut ostream, &value).unwrap();
+                    ostream.flush().unwrap();
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn _doit(&self, dry_run: bool) -> Result<Result<(), DoitError>, Option<InvalidOptionsError>> {
+        let mut err = InvalidOptionsError::new();
+        let mut call_result: Result<(), DoitError> = Ok(());
+        let mut err_opt: Option<InvalidOptionsError> = None;
+        match self.opt.subcommand() {
+            ("documents", Some(opt)) => {
+                match opt.subcommand() {
+                    ("analyze-entities", Some(opt)) => {
+                        call_result = self._documents_analyze_entities(opt, dry_run, &mut err);
+                    },
+                    ("analyze-entity-sentiment", Some(opt)) => {
+                        call_result = self._documents_analyze_entity_sentiment(opt, dry_run, &mut err);
+                    },
+                    ("analyze-sentiment", Some(opt)) => {
+                        call_result = self._documents_analyze_sentiment(opt, dry_run, &mut err);
+                    },
+                    ("analyze-syntax", Some(opt)) => {
+                        call_result = self._documents_analyze_syntax(opt, dry_run, &mut err);
+                    },
+                    ("annotate-text", Some(opt)) => {
+                        call_result = self._documents_annotate_text(opt, dry_run, &mut err);
+                    },
+                    ("classify-text", Some(opt)) => {
+                        call_result = self._documents_classify_text(opt, dry_run, &mut err);
+                    },
+                    _ => {
+                        err.issues.push(CLIError::MissingMethodError("documents".to_string()));
+                        writeln!(io::stderr(), "{}\n", opt.usage()).ok();
+                    }
+                }
+            },
+            _ => {
+                err.issues.push(CLIError::MissingCommandError);
+                writeln!(io::stderr(), "{}\n", self.opt.usage()).ok();
+            }
+        }
+
+        if dry_run {
+            if err.issues.len() > 0 {
+                err_opt = Some(err);
+            }
+            Err(err_opt)
+        } else {
+            Ok(call_result)
+        }
+    }
+
+    // Please note that this call will fail if any part of the opt can't be handled
+    fn new(opt: ArgMatches<'n>) -> Result<Engine<'n>, InvalidOptionsError> {
+        let (config_dir, secret) = {
+            let config_dir = match cmn::assure_config_dir_exists(opt.value_of("folder").unwrap_or("~/.google-service-cli")) {
+                Err(e) => return Err(InvalidOptionsError::single(e, 3)),
+                Ok(p) => p,
+            };
+
+            match cmn::application_secret_from_directory(&config_dir, "language1-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.is_present("debug-auth") {
+                                            hyper::Client::with_connector(mock::TeeConnector {
+                                                    connector: hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())
+                                                })
+                                        } else {
+                                            hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new()))
+                                        },
+                                        JsonTokenStorage {
+                                          program_name: "language1",
+                                          db_dir: config_dir.clone(),
+                                        }, Some(FlowType::InstalledRedirect(54324)));
+
+        let client =
+            if opt.is_present("debug") {
+                hyper::Client::with_connector(mock::TeeConnector {
+                        connector: hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new())
+                    })
+            } else {
+                hyper::Client::with_connector(hyper::net::HttpsConnector::new(hyper_rustls::TlsClient::new()))
+            };
+        let engine = Engine {
+            opt: opt,
+            hub: api::CloudNaturalLanguage::new(client, auth),
+            gp: vec!["$-xgafv", "access-token", "alt", "bearer-token", "callback", "fields", "key", "oauth-token", "pp", "pretty-print", "quota-user", "upload-type", "upload-protocol"],
+            gpm: vec![
+                    ("$-xgafv", "$.xgafv"),
+                    ("access-token", "access_token"),
+                    ("bearer-token", "bearer_token"),
+                    ("oauth-token", "oauth_token"),
+                    ("pretty-print", "prettyPrint"),
+                    ("quota-user", "quotaUser"),
+                    ("upload-type", "uploadType"),
+                    ("upload-protocol", "upload_protocol"),
+                ]
+        };
+
+        match engine._doit(true) {
+            Err(Some(err)) => Err(err),
+            Err(None)      => Ok(engine),
+            Ok(_)          => unreachable!(),
+        }
+    }
+
+    fn doit(&self) -> Result<(), DoitError> {
+        match self._doit(false) {
+            Ok(res) => res,
+            Err(_) => unreachable!(),
+        }
+    }
+}
+
+fn main() {
+    let mut exit_status = 0i32;
+    let arg_data = [
+        ("documents", "methods: 'analyze-entities', 'analyze-entity-sentiment', 'analyze-sentiment', 'analyze-syntax', 'annotate-text' and 'classify-text'", vec![
+            ("analyze-entities",
+                    Some(r##"Finds named entities (currently proper names and common nouns) in the text
+        along with entity types, salience, mentions for each entity, and
+        other properties."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_analyze-entities",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ("analyze-entity-sentiment",
+                    Some(r##"Finds entities, similar to AnalyzeEntities in the text and analyzes
+        sentiment associated with each entity and its mentions."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_analyze-entity-sentiment",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ("analyze-sentiment",
+                    Some(r##"Analyzes the sentiment of the provided text."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_analyze-sentiment",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ("analyze-syntax",
+                    Some(r##"Analyzes the syntax of the text and provides sentence boundaries and
+        tokenization along with part of speech tags, dependency trees, and other
+        properties."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_analyze-syntax",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ("annotate-text",
+                    Some(r##"A convenience method that provides all the features that analyzeSentiment,
+        analyzeEntities, and analyzeSyntax provide in one call."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_annotate-text",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ("classify-text",
+                    Some(r##"Classifies a document into categories."##),
+                    "Details at http://byron.github.io/google-apis-rs/google_language1_cli/documents_classify-text",
+                  vec![
+                    (Some(r##"kv"##),
+                     Some(r##"r"##),
+                     Some(r##"Set various fields of the request structure, matching the key=value form"##),
+                     Some(true),
+                     Some(true)),
+        
+                    (Some(r##"v"##),
+                     Some(r##"p"##),
+                     Some(r##"Set various optional parameters, matching the key=value form"##),
+                     Some(false),
+                     Some(true)),
+        
+                    (Some(r##"out"##),
+                     Some(r##"o"##),
+                     Some(r##"Specify the file into which to write the program's output"##),
+                     Some(false),
+                     Some(false)),
+                  ]),
+            ]),
+        
+    ];
+    
+    let mut app = App::new("language1")
+           .author("Sebastian Thiel <byronimo@gmail.com>")
+           .version("1.0.7+20171204")
+           .about("Provides natural language understanding technologies to developers. Examples include sentiment analysis, entity recognition, entity sentiment analysis, and text annotations.")
+           .after_help("All documentation details can be found at http://byron.github.io/google-apis-rs/google_language1_cli")
+           .arg(Arg::with_name("url")
+                   .long("scope")
+                   .help("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.")
+                   .multiple(true)
+                   .takes_value(true))
+           .arg(Arg::with_name("folder")
+                   .long("config-dir")
+                   .help("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")
+                   .multiple(false)
+                   .takes_value(true))
+           .arg(Arg::with_name("debug")
+                   .long("debug")
+                   .help("Output all server communication to standard error. `tx` and `rx` are placed into the same stream.")
+                   .multiple(false)
+                   .takes_value(false))
+           .arg(Arg::with_name("debug-auth")
+                   .long("debug-auth")
+                   .help("Output all communication related to authentication to standard error. `tx` and `rx` are placed into the same stream.")
+                   .multiple(false)
+                   .takes_value(false));
+           
+           for &(main_command_name, about, ref subcommands) in arg_data.iter() {
+               let mut mcmd = SubCommand::with_name(main_command_name).about(about);
+           
+               for &(sub_command_name, ref desc, url_info, ref args) in subcommands {
+                   let mut scmd = SubCommand::with_name(sub_command_name);
+                   if let &Some(desc) = desc {
+                       scmd = scmd.about(desc);
+                   }
+                   scmd = scmd.after_help(url_info);
+           
+                   for &(ref arg_name, ref flag, ref desc, ref required, ref multi) in args {
+                       let arg_name_str =
+                           match (arg_name, flag) {
+                                   (&Some(an), _       ) => an,
+                                   (_        , &Some(f)) => f,
+                                    _                    => unreachable!(),
+                            };
+                       let mut arg = Arg::with_name(arg_name_str)
+                                         .empty_values(false);
+                       if let &Some(short_flag) = flag {
+                           arg = arg.short(short_flag);
+                       }
+                       if let &Some(desc) = desc {
+                           arg = arg.help(desc);
+                       }
+                       if arg_name.is_some() && flag.is_some() {
+                           arg = arg.takes_value(true);
+                       }
+                       if let &Some(required) = required {
+                           arg = arg.required(required);
+                       }
+                       if let &Some(multi) = multi {
+                           arg = arg.multiple(multi);
+                       }
+                       scmd = scmd.arg(arg);
+                   }
+                   mcmd = mcmd.subcommand(scmd);
+               }
+               app = app.subcommand(mcmd);
+           }
+           
+        let matches = app.get_matches();
+
+    let debug = matches.is_present("debug");
+    match Engine::new(matches) {
+        Err(err) => {
+            exit_status = err.exit_code;
+            writeln!(io::stderr(), "{}", err).ok();
+        },
+        Ok(engine) => {
+            if let Err(doit_err) = engine.doit() {
+                exit_status = 1;
+                match doit_err {
+                    DoitError::IoError(path, err) => {
+                        writeln!(io::stderr(), "Failed to open output file '{}': {}", path, err).ok();
+                    },
+                    DoitError::ApiError(err) => {
+                        if debug {
+                            writeln!(io::stderr(), "{:#?}", err).ok();
+                        } else {
+                            writeln!(io::stderr(), "{}", err).ok();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    std::process::exit(exit_status);
+}