When caching a status, cache its reblog too.

That's another whole status, which we should be able to look up.

Reclassify status info as a utility activity.

I meant it to be that in the first place - that's why I entered
InfoStatus in the utilities enum. But then I forgot it was there and
made a separate entry for it.

When you're invoking status info from within a file, I think it makes
more sense as a utility, the way I first had it.

Support saving login details. We can now log in!

Move TopLevelError up to the root of the crate.

If that's not a candidate for putting at the top level then I don't
know what is.

Implement the login procedure, without saving.

Currently, the JSON-serialised AuthConfig is written to stdout, just
to prove during development that it works. Next step is to save it to
where it ought to live.

Actually post something!

Post-compose menu, up to but not including posting.

Give MenuKeypressLine a width reset option.

Then when I change menu items on the fly they won't always remember
the largest width the menu has ever had.

Move prompt into SingleLineEditor.

It was a mistake to put it in the wrapping BottomLineEditorOverlay,
because I'm going to want to put single-line editors elsewhere on the
screen with the same kind of prompt.

Update html2text to 0.10.1.

Chris has released a version containing my pull request that supports
the <del> tag, which I encountered in a toot last month.

Editor: implement cut to end of line.

Fix handling of newlines in is_char_boundary.

Newlines have width 0, so we were mis-classifying them as a combining
character, causing the point just before one to be considered not a
character boundary!

Editor: support beginning/end of line.

Editor: support page-up and page-down.

Not very useful just yet while we're not able to scroll to keep the
cursor in view, but even so, it's nice to be able to get to the bottom
quickly!

Editor: implement Up and Down keystrokes.

Editor: make the cursor position persist.

Then we'll still have it available to refer to when processing
keystrokes.

Fix an edge case of watching a nearly empty feed.

This just came up when testing against a dev instance, which starts
off with 0 posts anywhere, of course.

Develop an explicit HTTP redirection policy.

The Mastodon dev system runs its streaming API on a different port of
its VM. So you need to be able to follow an HTTP redirect from
http://mastodon.local to http://mastodon.local:4000 and still pass the
same auth token to that server.

But in general, one should not keep authentication configuration when
traversing a cross-site redirection! reqwest's automated redirect
following won't do it at all, and rightly so.

So I've written a custom redirection policy which allows _same_-host
redirection (just in case something turns out to need it), and doesn't
follow cross-site redirection (which would in general be useless
anyway because of this auth issue). And when setting up the streaming
API in particular, we catch the unfollowed redirection, vet it very
carefully (against the official streaming API location which the
instance happily advertises in its configuration record), and if we're
satisfied, make a fresh request to the target URL which _does_ pass
the same authentication.

As a result, now we can do streaming to the Mastodon dev instance,
which the Python version of this client _never_ managed!

Make AuthError into a subcase of ClientError.

Now tui.rs doesn't have to handle it directly, and our client setup
can return the more general ClientError.

Fix movement by words in the editor buffer.

I apparently only half-finished writing is_word_boundary: it tested
that the _next_ character wasn't a space, but not that the previous
one was.

Start of a full-screen editor for composing toots.

You can't actually post anything. And none of the keystrokes special
to the composing editor is implemented yet (ok, except [^O][Q] to quit
the editor). But you can at least start typing text into the buffer,
and it gets wrapped, colourised, and checked for being too long.

Make our regex scanner into a lazy_static.

That way we only construct it once per runtime, not once per Editor we
instantiate. I've just realised that that must be what's making some
of my half-written editor unit tests slow.

Decentralise version component of API URLs.

I thought it was /api/v1/whatever, but I've just realised that it's
actually /api/v2/instance in particular. _That's_ why I keep seeing
"uri" from some servers and "domain" from others: if I requested the
up-to-date version of the record, it would agree on "domain".

Fix test failure introduced by format_date.

I didn't read carefully enough the code I was replacing with a
function call. It had an extra space at the end of the date format
string.

Support retrieving the Instance object.

Not much of it is decoded at the moment, but we'll need a few pieces
of configuration to inform the post composer about important things
like how to tell when it's hit its length limit.

Fill in percentage in file status lines.

I was putting that off because I had a half-formed clever idea about
trying to do linear regression on the posts we _have_ formatted to the
current width, and using it to estimate the likely line height of the
ones we haven't. But then I decided that was either the perfect being
the enemy of the good, or a silly idea that was bound to explode in an
edge case, or both, and so I've done something simple instead.

The _main_ purpose is that '100%' means 'nothing more to read' and
anything less means there is. As long as we get that much right, we're
in reasonably good shape.

Elide 'foo: foo' in struct literals where possible.

Another thing I only just realised: although in general you're
supposed to explicitly say the name of each field you're initialising,
there's a special case where you can leave it out if the name of the
local variable you're initialising it _to_ is exactly the same.
Presumably on the grounds that that still doesn't allow much
confusion, and is terser.

Remove lots of commas after braced match arms.

I only just noticed from reading someone else's Rust code that they
aren't syntactically necessary!

Stop using ~ around struck-out text.

Apparently html2text is completely happy to render strikeout via
U+0336 COMBINING LONG STROKE OVERLAY, and needs no support from the
terminal escape-sequence system at all. So I don't need an artificial
indication that it happened.

Support reading hashtag feeds.

No trouble at all given the existing infrastructure.

Fill in the rest of View Post Info.

Remove some assorted dbg! I don't need any more.

Start of View Post Info.

Currently it just shows the post in the ordinary way, without all the
extra detail. But it's plumbed through the menus, which is a start.

Filled in account flags.

I think that's Examine User all done now!

Leave out the double-check of the account name.

Turns out it's case-insensitive, bah.

Show account relationships.

Filled in most of the Examine User data.

The missing part is Relationships, because those are a separate
server-side data structure.

Sorted out the approximate dates in Account.

I couldn't parse last_status_at as a DateTime<Utc> in all cases at
all, and even in created_at, the time part was clearly nonsense.

chrono has an actual type for this, so let's use it! With bonus Baby's
First Custom Deserialize Impl.

Make the [ESC][Y] shortcut work.

Useful to do this before I start filling in the rest of the Examine
User display, so that it's quick to test it each time!

Start of an actual Examine User display.

Doesn't contain most of the information yet, but we have the Account
struct in hand and can start filling it in.

UNFINISHED examine

Abstract out FeedDataSource.

Now a FileContents doesn't _have_ to contain a FeedId; I can replace
it with an alternative trait implementation containing a fixed set of
things.

Rename FeedFile and friends.

The scrolling-file system is about to be reused for things that aren't
feeds, so it will be confusing to have the structs all called FeedThing.

Ability to abort a bottom-line prompt.

The new PopOverlay logical action returns to the previous non-overlay
activity, without reinitialising it.

Use todo!() in place of panic!("FIXME").

I only just found out about that, and I should start getting into the
habit.

Make the Examine prompt chain to another activity.

Doesn't _work_, because I haven't actually implemented that activity
yet. We now panic in a FIXME in tui.rs. But it's a start.

UNFINISHED: first overlay activity: Examine User prompt.

This doesn't actually examine users yet. When you press Return at the
prompt, it just beeps, because transferring the data to where you
actually wanted it is not yet implemented. But it's enough to test the
editing itself.

Introduce the concept of an 'overlay activity'.

This will be used for bottom-line editor prompts. Some of those are
triggered within the context of an existing activity (for example, if
you're reading a file and press the not-yet-implemented search key).
Others can be imposed from outside, e.g. pressing Alt+E while reading
a file. So there's a slightly fiddly mechanism to make the latter
work, and not treat it as two totally independent ESC and E
keystrokes (which would leave you looking at the Utilities Menu while
entering the name of a user to examine, instead of at the screen you
saw the username on).

The overlay activity is drawn on top of the topmost non-overlay
activity on the stack, at the bottom of the screen.

Enough editing keys for a single-line editor.

Start of text editing: the EditorCore type.

This is the common piece between bottom-line text entry and the
full-screen post composer, handling all the editing keys that work the
same in both.

Fix panic when going to Read Mentions.

My rewrite of the ensure_enough_rendered loop introduced a further bug
in which we counted the number of visible lines of the bottom item
_plus_ its full height. Should have been _instead of_ its full height.
So we didn't get right to the top of the screen.

Braino: < for <=.

Would have caused an unnecessary coarsen_pos() if we were sitting on
the first _non-header_ item in a file at the point when it failed to
extend backwards.

Don't put '?' on the end of parameterless URLs.

If you call reqwest::Url::parse_with_params and give it an empty
parameter iterator, it still appends '?' to the URL, and then doesn't
put anything after it.

I don't _think_ that actually makes any difference, but it looks ugly.
More to the point, I noticed it while pasting HTTP transcripts to
report a bug in the Mastodon dev setup, and thought I'd better try
again without the spurious '?', in case it did make a difference.

Make this program build on Windows!

I tried it out of pure curiosity. As I expected, the 'xdg' crate
didn't work (I already knew it was documented to not work on Windows),
but everything else was fine, and it compiles and runs!

Report HTTP errors from all URLs we retrieve.

Fix misreporting of HTTP errors not about auth.

The prefix "unable to read authentication" was in the wrong part of my
error handling edifice.

Fix extending a totally empty home timeline.

Again, probably only likely to come up in a new dev instance - but in
that situation, you do need it to work!

UNTESTED: go to Read Mentions if user is mentioned.

Annoyingly, I can't test this on the dev instance, because its
streaming API doesn't work!

File draw method: add a missing bounds check.

Don't try to render an item that doesn't even exist at all.

ensure_enough_rendered: forgot to render bottom item!

We must render the actual item that our current position points at, as
well as the ones before that. I had my loop backwards.

Call ensure_enough_rendered even if feed update failed.

Because then we're tinkering with the ExtendableIndicator, so we still
need to re-check our drawability.

Replace an assert with sensible handling.

It came up the first time I tried to test on a dev instance.

Initial command-line parser.

Allows '-c some_directory' to specify a non-default config dir.

Reorganise startup to pass in a config location.

This begins to set up for specifying a non-default one on the command
line, which I'm going to need in order to start doing testing that
depends on a local test Mastodon instance.

Implement the Ego Log.

This also meant fixing a loose end in the NotificationLog text
fragment type: it was still expecting to receive a Vec<Paragraph>,
because that's what it would have had available before we moved back
to html2text. Now it takes a single Paragraph, expecting that
Html::to_para() has sorted that out already.

Add the Read Mentions feed.

Teach Client about the Notification type in the API.

Make FeedFile generic across type of item.

Now it can hold some other kind of TextFragment, instead of always
being StatusDisplay.

Remove some pubs from html.rs.

Just spotted that those aren't really needed.

Use feed updates to lengthen the home timeline.

Untested as yet, but this _should_ replicate the behaviour from the
Python version where you're reading your home timeline and a new post
quietly appears below what you can currently see.

Fix help message.

Begin setting up the streaming subthread system.

This gives Client two new methods. The first starts a subthread
listening to a stream, given a lambda function that you pass into the
subthread to handle the response. The second runs in the context of
the main thread, and the idea is that you give that same response
straight back to the client.

The owner of a Client object is responsible for doing the plumbing in
between, to arrange that a response passed to the lambda in the
subthread is transferred back to the main thread and given to
process_stream_update.

The implementation of that plumbing in Tui sends the data back to the
main thread over a clone of the sync_channel we already had, so that
it's received in the same event loop as terminal input.

So far, nothing is done with the updates.

Also not done: it would be nice to be able to ask a subthread to
terminate, if it's not needed any more. That way if the user tries to
read one of the fast-moving public timelines, we can dismiss its
update thread as soon as they're not looking at that file any more.

Add a couple more primary timelines.

Ability to extend the feed backwards in time.

Haven't yet tested the part where extension runs out, though. That
will be easier when we get some more kinds of feed, so I've left a
FIXME comment in there.

Remove an unnecessary drop.

I had imagined that explicitly dropping a reference would terminate a
borrow. But firstly, rustc 1.74 says it does nothing at all, and
secondly, therefore I infer that this particular borrow wasn't in the
way in any case.

Migrate back to html2text.

I gave up on using it previously because it lacked some important
features - in particular, it didn't support CSS on <a> elements, which
is necessary for identifying hashtags and mentions in Mastodon's
output HTML.

In 0.9.2 that feature is present, so I can try again! Also, 0.9.2 has
the neat ability to save the RenderTree that's an intermediate product
of the pipeline, just before we depend on the width. So we can keep
that after parsing a toot, and then only re-run the necessary back end
of the pipeline to re-render at a different width.

The amount of code is extremely reduced.

Use ratatui's Color::Gray instead of Color::White.

The former is the ESC[37m colour. The latter seems like the natural
name to my way of thinking, but it means tell the terminal you're
_really serious_ about wanting proper #ffffff.

Go to top and bottom of file.

I think this is all the basic 'paging around' actions done!

Add a file header!

Clip position at the top of the file.

Scrolling downward, too.

Scrolling upward mostly works.

Doesn't clip at the top of the file yet, but this is a start!

More or less principled file-position tracking.

We still can't actually _scroll_ through the file, because I haven't
made any actual keystrokes work yet. But we begin displaying it at the
bottom, and do something sensible on resizing.

Notify ActivityState mutably when it gets resized.

This should enable it to prepare anything it needs for the next
redraw.

Pass client through to handle_keypress.

Forgot to break overlong logical lines.

Now URLs show up in a way that you can actually paste into a browser.

Fix paragraph wrap width.

We were wrapping to the full screen width, instead of Monochrome's
traditional w-1.

Basically correct-looking display of toots \o/

Now we display the separator line of each toot. Progress!

URL in statuses is optional.

Reblogs don't have one: you can't view the reblogging status in the
web UI, only the reblogged one.

Now we try to actually fetch a feed.

It doesn't work! JSON parsing error.

Prepare to pass a Client through to activity constructors.

Temporarily squelch some warnings.

I _know_ all those things are unused - I haven't finished writing the
program yet. Shut up about them until I'm done!

Allow error reporting as a PhysicalAction.

Could easily come in useful!

Make a Client and put it in the Tui.

This involved souping up the error handling so that we can absorb
errors from various different sources during Tui construction.

Untested code to fetch feeds of items.

Readonly mode for the client.

This was very useful when I was testing the editor last time round,
and surely it'll be just as useful this time.

Forgot to make sure ESC G worked!

It _worked_ in the Python version, but I apparently left it out of the
visible menu options. But here they're more tightly tied together, so
leaving it out of the visible options made it not work at all.

Improved first couple of client operations.

Now we check errors sensibly rather than via cavalier .unwrap(); we
cache accounts as well as statuses per id; and we verify the returned
id against the one we asked for (to make it not an obvious attack
avenue to file things under the returned id).

Filled in all the rest of the menus.

Also, the actions that aren't implemented yet are clearly marked with
'NYI', and been if you try to select them.