Previously this wasn't the case, as the type could be inferred by the
type of the parent-vector to extend.
Apparently this feature was removed, probably for good reason.
CLI was slightly adjusted to not use unstable features.
Fortunately, there is no serde magic happening, which allows
us to keep it simple without using a build script.
Even though there is a bug that caues {} to be used in stead of
(),
when exanding macros, which causes syntax errors that we have to
workaround, it's not a real issue.
What's happening additionally is missing hyper macros, which
now have to be expanded manually. Shouldn't be a problem,
pretty-printing when compiling is made for just that ;).
No, it's sad that `include!()` works so badly, it makes
using serde so difficult ... it's no fun i must say.
Just for stable ... I am not sure if it is worth it."
We save about 30% of CLI code just because we offload the work of
settings structures into serde, building a generic `json::Value` to
contain all the data, and then let serde do the deserialization for us.
All we need for that is some information we let the generator provide
and translate it into the runtime.
Closes#111
* recurively drill down a mutable, recursive enumeration, without borrow
checker issues. The obvious solution doesn't work, but should.
Stackoverflow ?
* infrastructure to set actual value, with support for ararys, pods and
hashmaps
Previously we only knew the type as string, now we have enums and
additional type information, like whether or not it's a POD.
However, borrow-checker doesn't like the current code, will need more
work.
Previously we would set static structures manully, using complex cases
and utility functions. Now we setup the foundation to allow setting
a generic `json::value::Value` instead, which can later be deserialized
into the target structure.
Related to #111
* Vec::add was removed ... which forces me to write 4 lines instead of
one very readable one :(.
Not everything is to the better here, even though I can imagine they
did it to prevent people from thinking this is a cheap operation.
[skip ci]
That way, it's easy to obtain the respective precompiled binary, as
well as seeing the source-code.
Overall, it makes promoting the tools easier as the CLI docs can be
linked directly.
Closes#108
[skip ci]
That way, whenever the extended help of a method (e.g. apis get-rest)
is queried, you can easily jump to the online docs to get details about
required data-structures or parameters for instance.
[skip ci]
Without all that clutter, it's so much more enjoyable to read the
output.
The implementation is based on a suggestion of @erickt, which is
converts into a json::Value (able to represent any json structure),
on which the filtering is applied.
If we should ever implement pretty-printing in json-tools, we might
still consider using these capabilities instead, as we would avoid
building potentially large datastructures, all we would need is
a sufficiently large destination buffer which is a single alloc and
a consecutive region in memory.
Closes#102
[skip ci]
Instead of using multiple lines to add vectors up involving iterators,
I just add slices together. This should produce less, and possibly
faster machine code, with less ascii code.
Downloads tested with drive2, and are verified to be working !
Close#97
Global params were repeated per method, even though they were global,
per API. Now they are kept in vectors and used at runtime, accordingly.
We save a little bit of code, have simple matches, and less repition.
It's unclear if this reduces the size of the binary though ... or the
compile times, as the extra loop is an extra loop after all ;).
Still need to test the download mode using drive1
Related to #97
[skip ci]
* functionality is cursor-aware, and fixes the actual string the user
passed in. That way, it is made very clear how the suggested value
is to be used.
* it's a known weakness of the implementation that it operates on a
flattened list of field names, and thus may make nonsensical
suggestions.
* added punctuation to all errors
Fixes#67
[skip ci]
Previously the local stack variable would be used even though it
wasn't initialized as there were no upload flags. Now this only
happens if there are media params.
[skip ci]
* As `possible_values()` applies to all arguments, we cannot use it
anymore but have to check the UploadProtocol type ourselves.
Besides that, switching to the latest `clap` simplified our lives
a little.
* ajusted docs to not enforce using `-r` all the time
Fixes#92
[skip ci]
* Use `Result` everywhere, instead of Option or tuples
* Properly handle error occurring after the dry-run. We do it in an
extensible way, in case we need to do more than handle invalid output
files at some point. Output files that could not be opened will now
result in a nice error message with all the information we have.
Fixes#66
* More detailed error type for JsonTokenStorage
* removed all traces of rustc_serialize
* use pretty-printers everywhere to allow writing human-readable json
files for secretes and for tokens
Fixes#93
* adjust documentation to resemble actual upload flag semantics. It was
still using the one previously used in docopt.
* Make -m <mime-type> optional, defaulting to 'application/octet-stream'
Should have been fixed alongside of #81
* CallType now represents either Upload or Standard calls, whereas
the Upload variant is represented by the UploadProtocol enum.
That way it's clear what happens, and we don't mix orthogonal concepts
in one enumeration just for convenience.
All tested APIs seem to build, verified
* upload
* download
* request structures
* parameters
* scopes
* config-dir
* debug[-auth]
Fixes#81
* mkdoc docs grammar is now hierarchical, making the command structure
more obvious and easier to understand. It's a nice addition to the
auto-generated, hierachical usage of clap.
* UploadProtocol enum is now CallType, to ease handling the different
ways the Call has to be executed. It looks quite clean, even though
combining upload protocols and the calltype is a bit hacky.
* `--version` now includes the API revision we embody
(using crate_version())
* Allow multiple scopes to be specified, instead of just one. Previously
this was problemantic due to argument parsing of docopt being greedy.
However, this also means we have to specify the `-r` flag for each
invocation. See https://github.com/kbknapp/clap-rs/issues/89 .
* Adapted to new signature of `Arg::possible_values()` and used the
previously orphaned `UploadProtocol` enum.
* Deduplicated code a little by adding the new `opt_values()` generator
function.
Related to #81
As IntoIter is only implemented for slices up a sice of 32.
DFAReporting though will reach 55, at least.
Also added dfareporting-cli code to show how stackoverflow issues can be
circumvented efficiently.
We will try to wait for https://github.com/kbknapp/clap-rs/issues/87
to allow us to use the enumeration instead of strings, as well as
an iterator, which will look more idiomatic in the end.
We are currently setting everything up at runtime, and manage to get
nearly all information into it, except for the more complex
`-u (simple|resumable) <file> <mime>` flag.
Fixes#87
Related to #81
We do this in the hopes to circumvent a stack overflow.
This means we will setup the parser entirely at runtime, which actually
saves a little bit of code.
Previously, the space was barely visible, confusing even myself :).
Now it's clear, using 4 spaces, that there is a cursor invocation
followed by a key-value pair.
* now the cursor will only be set permanently if the -r flag is used in
'cursor' mode. In 'cursor=value' mode, the cursor change doesn't
persist among the flags. That way, one can easily distinguish
between setting the cursor, and setting a field. However,
'...sublevel.level=value' will still work as it did previously, yet
the cursor change will not persist.
* Documentation was adjusted to represent the new cursor style.
Fixes#86
Previously, even though the request was passed by reference, it was
copied and thus our changes never arrived in the call.
Now the API makes this clear by taking ownership, and the CLI code
sets the Request value lateron, explicitly.
Related to #76
* implement custom scopes - previously they could be set, but were
ignored during the API call
* api-overrides are not yaml files for convenience. Existing ones were
updated as needed.
Fixes#75
We are now able to decode detailed errors and pass them on. This allows
the CLI to provide more useful error responses.
Additionally, the CLI will only print debug responses in --debug mode.
Fixes#82
