I've switched to a new M1 laptop which couldn't build the old dependencies because the old ring library version doesn't compile on mac arm (but new version do). There's no way to update ring in isolation, so I've got to update the whole tree at once.
Otherwise it's possible to leave bytes related to a previous version
of the file in tact, tailing the newly written content.
This in turn leads to malformed json when tokens are rewritten.
This seemed easiest, especially since I also am the author of
pulldown-cmark-to-cmark :D.
Funny how things fit together sometimes. And so much better than
if I would have tried the same in pure python.
change `remove_json_null_values()` to properly remove nulls from and recurse in to arrays
google_firestore1_beta1's `CommitRequest` contains an array of `Write` objects which can ultimately
contain `Value` members that need to have nulls removed to avoid sending multiple types of values
which generates a 400 response
fixes calls to google_firestore1_beta1's `hub.projects().databases_documents_commit()`
Considering we kind-of hardcoded this authentication type anyway,
we now use the Auth-types provided by hyper 0.8.
The incentive here was the compiler telling us that there the
yup-oauth::Scheme type doesn't implement the hyper::authorization::Scheme
anymore, even though that clearly was the case. Also it couldn't be
reproduced in yup-oauth itself.
This will need some work to get correct again, so this is just a crude
patch to make it work again.
However, in sibling libraries, we still use time::Duration, which
now is a part of std::time::Duration.
These should be adjusted, to make the usage of
sleep(Duration::from_millis(d.num_milliseconds() as u64)) into sleep(d)
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
However, we don't set the correct field names yet, and are lacking
a remapping of CLI field names to struct field names before any
testing makes sense.
* 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
Previously you would only see "BadRequest ... " without the information
that would actually help you to understand what the cause of the issue
is.
Now we will print all the information we have, accordingly, which
greatly improves usability.
Closes#103
[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]
