Use t.Fatal instead of t.Error + return, it's shorter and simpler.

Use ReadFile from package os instead of the deprecated io/ioutil.

Add test coverage for one more edge case, however unlikely it is.

Commit 2a3c46a829b9 added support for supportsFamily, an API new to
macOS 10.15. It used an @available check to avoid trying to call it
on macOS 10.13 and 10.14, but despite not running, it still creates
a warning like:

	mtl.m:44:33: warning: instance method '-supportsFamily:' not found
		(return type defaults to 'id') [-Wobjc-method-access]

On those old macOS versions.

Use an #ifdef directive until I find a better to handle this, or drop
this complexity by raising the minimum supported macOS version.

Tested on macOS 10.13.6 and 13.0.1.

The upstream Metal API has deprecated this part of its API.
Explicitly ignore a compilation warning about the deprecation.

The GerritProject.GitCommit method in x/build/maintner returns an error
as of https://go.dev/cl/407394. Start using its new API.

With the new specification, it's possible to stop reading a file early
even when the generated comment is absent, since the generated comment
may no longer appear anywhere in the file. Begin parsing /* */ comment
blocks, which may span multiple lines, to be able to be able to detect
when we run into the first non-comment, non-blank text in the file.

It was mentioned in https://go.dev/issue/41196#issuecomment-686607452:

> [...] the primary focus for these comments is Go code
> and more generally Go package sources.
> Go package sources today can be Go, assembly, C, C++, Objective C,
> SWIG, and Fortran.
> The comment being discussed here, like the //go:build comment,
> handles all of these these except Fortran, which seems fine.

The initial scope of this package was to support parsing Go source only,
but it happens to work well with many other source types that are found
in Go packages. Replace mentions of "a Go source file" in documentation
and code with "a source file", to make it apply more generally. If this
will mean we need to parse comments differently depending on the source
type in the future, we can revisit this decision. Let's see how it goes.

Fixes issue 1.

Reviewed-On: https://dmitri.shuralyov.com/go/generated/...$changes/1

This is because by now requests to godoc.org redirect to pkg.go.dev¹.

¹ https://blog.golang.org/godoc.org-redirect

The go command doesn't impose a limit of at most one import path pattern
to be provided. We shouldn't either.

This is a newer API to check whether a GPU device supports the feature
set of a specific GPU family. It's available on macOS since 10.15.

The Objective-C BOOL type is defined as a signed char on on Intel-based
Mac computers, but on Apple silicon, it is defined as as a native bool.¹

This makes it hard to write portable Cgo code across darwin/amd64 and
darwin/arm64 ports. So, stop relying on it, and use the bool type from
<stdbool.h> instead.

¹ https://developer.apple.com/documentation/apple_silicon/addressing_architectural_differences_in_your_macos_code#3616879

The clone calls run once at startup and take a good while to complete,
so make them verbose to make progress more visible.

Go 1.15 has been released recently, so start using it.

Updates https://dmitri.shuralyov.com/website/gido/...$issues/3.

The golang.org/x/pkgsite repository was added in golang.org/cl/222737.

Updates https://github.com/golang/go/issues/36747.

It will be used for setting the onclick property for anchor elements.
This is needed for https://github.com/shurcooL/home/issues/40.

The golang.org/dl repo is a special case because it doesn't include
the "x" element like other golang.org/x repos. Handle it specially.

Follows https://dmitri.shuralyov.com/go/prefixtitle/...$commit/500817462677553a6769e268d66193c36b423cd6.

Add 1.14 and drop 1.12 in order to get with the times.

Updates https://dmitri.shuralyov.com/website/gido/...$issues/3.

The golang.org/dl repo is a special case because it doesn't include
the "x" element like other golang.org/x repos. Handle it specially.

Add 1.13 and drop 1.11 in order to get with the times.

Updates https://dmitri.shuralyov.com/website/gido/...$issues/3.

This code has gotten quite terse and hard to understand.
Refactor it, without changing behavior, so it is easier
to read and extend.

There are now two separated sections. One adds issues/changes to
issuesAndChanges. Another populates {open,closed}{Issues,Changes}.

The next commit will fix an omission.

Updates https://dmitri.shuralyov.com/website/gido/...$issues/5.

Regenerate assets after relevant change to reactionsmenu in commit
https://github.com/shurcooL/frontend/commit/441c9e127002027fa90dd53f21dc6d380217afd7.

Updates https://github.com/shurcooL/home/issues/34.

It has become unnecessary after the switch from GLFW v3.2 to v3.3,
because Window.GetCocoaWindow now returns unsafe.Unsafe directly.

This wasn't needed in the past, but by now it is neccessary
for MTLCreateSystemDefaultDevice to work.¹

¹ https://developer.apple.com/documentation/metal/1433401-mtlcreatesystemdefaultdevice

This came up during code review in https://golang.org/cl/171025.
Backport the improvements to the upstream copies of those packages.

These are better names for these Go packages. The previous names were
an attempt at leveraging the familiarity with Apple's API prefixes
(i.e., AppKit identifiers tend to have "NS" prefix, Core Animation API
identifiers tend to have "CA" prefixes). However, that isn't as useful
here because those prefixes are not very consistent or recognizable
when turned into Go package names.

Create a helper to convert from bool to C.BOOL and use it instead of
more verbose switches. Other people seem to like this style better.

It has been released recently. Start using it.

Updates https://github.com/go-gl/glfw/pull/256

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

Make the BSD 3-Clause license easier to see by adding a LICENSE file
to the repository. Use the same format as https://golang.org/LICENSE.

This change makes it possible to see the people who were requested
as reviewers, which helps understand the context for notifications
about CLs better.

Sort inline comments by file name and line number, so that their order
is deterministic. Previously, it was non-deterministic due to reliance
on map iteration order.

There's still a small chance for non-determinism in comment order when
there are multiple inline comments in the same file on the same line.
Leave dealing with that case for later when running into it concretely,
because it's not clear if it's something that can actually happen.
If it becomes necessary to resolve it, it should be possible to use
inline comment IDs to break the tie.

These methods will be used to produce links to issue and PR events.

When calling List or Count with change.FilterAll, omit the "states"
argument from the GraphQL query, rather than using an empty list ([]).

This is simpler and produces more consistent results.¹

¹ https://github.community/t5/GitHub-API-Development-and/Inconsistency-of-empty-state-filter-between-Repository-issues/m-p/30659#M2888

Changes that have an import path that doesn't correspond to any
existing directory, but do have a non-empty root, are considered
to belong to the root directory. Add them, so they show up as
expected when doing an import path pattern query that matches
a repository root.

This edge-case was originally unintentionally overlooked.

Fixes https://dmitri.shuralyov.com/website/gido/...$issues/5.

Previously, the default open tab could only be selected by not
providing the state query. Add support for selecting the default
open tab with an explicit ?state=open query too.

Similar to https://github.com/shurcooL/issuesapp/commit/0b82558264994ab993533eed0d2cfe83e145dbe5.

Previously, when using an import path pattern to query issues or CLs,
issues or CLs that had more than one import paths associated with
them had a chance of being displayed multiple times (if more than
import path matched the import path pattern).

Fix this by pre-computing lists of all issues and CLs along with
their import path associations, then use those lists when handling
import path pattern queries. This approach makes it easier to avoid
duplicate issues/CLs.

Fixes https://dmitri.shuralyov.com/website/gido/...$issues/4.

Also disallow multiple state query parameters.

This makes query parameter handling more precise and logical.

Use the same simpler style as in other projects.

Visualize the new event type in the change timeline.

Follows https://dmitri.shuralyov.com/service/change$commit/bd27112db59ba9f1e01f6d1e36ea7715c9dde98c.

This results in a more complete and readable timeline.

Populate it from Gerrit CLs. It's helpful to see when
new patch sets have been uploaded in between comments.

It's not supported by other change.Service implementations
yet, but that can be done when there's some demand for it.

Fetch to memory the latest commit of "master", "release-branch.go1.12",
"release-branch.go1.11" branches of all relevant Go repositories, and
then walk their trees to collect the list of directories. This scales
better than manually maintaining a list of Go packages.

For now, this is only done once at process start, and the release
branch names are hardcoded. This can be improved later.

Also add dl, example, mod, website, and xerrors sub-repositories.

Updates https://dmitri.shuralyov.com/website/gido/...$issues/3.

This functionality is factored out into a separate package
so that it can be reused across a wider set of projects.

This functionality is factored out of the gido website
so that it can be reused across a wider set of projects.

Follows https://dmitri.shuralyov.com/website/gido$commit/9ec8098d1ae7dcc4e4bcc249640bb5dec2a42b2c.

Apply this change to make the change rename event easier to read.

Follows https://github.com/shurcooL/issuesapp/commit/a359f164dfa502a21cdc4cc3582a5b4221308d2a.

It's helpful to visualize hashtags applied to CLs.
Do so by mapping them to labels.

This produces more accurate results and is consistent with similar
code elsewhere.

This change also improves handling of other PullRequestReviewState
values.

The commit message should always have a subject and headers,
but the body (providing additional information) may be absent.
Detect that case and return empty string, rather than erroneously
returning the headers as the body.

Also add some basic tests.

These were needed for a Metal API-based driver for x/exp/shiny.

Get the ContentView right away, instead of going through cocoaWindow.
The ContentView is all that's needed from cocoaWindow at this time.
This is simpler and reads better.

The motivation to do so is to simplify state and make it easier to
develop related projects. There will be fewer conversions needed.

Follows https://dmitri.shuralyov.com/service/change$commit/59022927fa7dea491c7a54393aec92ee4896717c.

This type will be used for representing possible states of a change
review across different code review systems (GitHub PRs, Gerrit CLs,
and other custom changes).

The possible values are largely based on the code review conventions
set up for the Go project. They are described at
https://groups.google.com/d/msg/golang-dev/YU56eKYiXJg/K1CkXo7Iy0gJ.

This is a starting point, the values may change if compelling reasons
to do so are discovered.

Comments are meant for entries that contain non-empty content. Some
entries contain, e.g., a Run-TryBot+1 vote, but otherwise empty body.
We may want to visualize such timeline entries in a more lightweight,
event-like manner. For now, just skip them instead of displaying
empty comments.

When a Gerrit CL change is restored, there should be an
associated ReopenedEvent. This change implements that.

I've finally encountered a Gerrit CL that was restored,
so this change could be tested on it:

	https://go-review.googlesource.com/c/build/+/169198

It has changed in https://github.com/sourcegraph/go-diff/pull/30.

Updates https://github.com/sourcegraph/go-diff/issues/27

It has changed in https://github.com/sourcegraph/go-diff/pull/30.

Updates https://github.com/sourcegraph/go-diff/issues/27

The responsibility of marking changes as read is being moved from
the service level to the changes application. It has already been
removed from the change service. In this commit, it's being added
to the changes application. Use the existing Options.Notifications
field that provides a notification service and its MarkRead method
for accomplishing this.

In general, it's easier for the changes application to know (with
higher certainty) when a change has been read by a user. For now,
it continues to happen whenever the HTTP handler serves a page that
displays a change. In the future, we can decide to mark a thread as
read when the user scrolls down and sees the new content, instead of
right away on page load.

Also update cmd/changesdev for githubapi.NewService API change.

Follows https://dmitri.shuralyov.com/service/change/githubapi$commit/09fc1cdc80ff92256db38ada7ae5bdecad9db138

The responsibility of marking changes as read is being moved from
the service level to the changes application. This approach scales
better.

It makes it possible to use the changes service for other internal
purposes. For example, it's being used internally as part of
implementing a Gerrit notification v2 service.

It also means the changes application can decide to mark a thread as
read when the user scrolls down and sees the new content, instead of
right away on page load.

In general, it's easier for the changes application to know (with more
certainty) when a change has been read by a user.

This specifies the notification thread type for Gerrit changes. It will
be used by the changes application for marking Gerrit changes read.

Give it a more specific name. This improves clarity of what it means
and how it's being used in the ThreadType method.

It will be used to generate links to Gerrit subjects on the
dmitri.shuralyov.com website.

This is more consistent with other change service implementations,
and provides more useful context when viewing the change discussion.

These events have been superseded by change.Review and its State field,
and removed from the change package. Delete support for them.

Follows https://dmitri.shuralyov.com/service/change/...$commit/9a7a6e8aef50bf7dceb93c681ed6446f3fdfa0b0.

These events have been superseded by Review and its State field.

At this time, the go.mod file specifies only the module path,
and nothing more.

In the future, it can be expanded to specify additional information,
such as the required modules and their versions, and the expected
Go language version. This will be considered after some time passes,
and the long-term implications of doing so are better understood.

At this time, the go.mod file specifies only the module path,
and nothing more.

In the future, it can be expanded to specify additional information,
such as the required modules and their versions, and the expected
Go language version. This will be considered after some time passes,
and the long-term implications of doing so are better understood.

Use the CurrentRevision of the CL to determine the merge commit,
rather than unsafely parsing it out of the human-readable message.

Background

Up until recently, all "autogenerated:gerrit:merged"-tagged messages
that I've encountered on the Gerrit instance at https://go-review.googlesource.com
have started with the 46-byte-long "Change has been successfully
cherry-picked as " string, followed by a 40-byte-long commit hash.

I didn't originally see a way to retrieve the merged commit from the
API response directly, so I implemented an unsafe string slice
operation that assumed the familiar message format.

A CL that used merge submit type rather than cherry-pick was submitted
at https://go-review.googlesource.com/c/go/+/164238/1#message-e75ad5d4bec9069a005bdc9efad6fbe8af8eb935
and generated a "autogenerated:gerrit:merged"-tagged message with
a different format, causing a panic.

By now, I've found a way to use the Gerrit API to determine the merge
commit. When a CL has an "autogenerated:gerrit:merged"-tagged messaged,
the CurrentRevision of the CL is the merge commit. Use it, since it's
more robust and safe.

This is yet another possible newPatchSet message format.

See example at https://go-review.googlesource.com/c/tools/+/151057/5#message-def598911f85f6435674a5ebeccc9981cfc59195.

I wasn't aware this method existed, that's why I wrote code
that does the same thing. Start using the Subject method now.

Their previous arrangement made it so that the PR review case
completely shadowed the PR review comment case, since
strings.HasPrefix(cr.ID, "r") is always true whenever
strings.HasPrefix(cr.ID, "rc") is true.

Display a closed event when a CL is abandoned, and the abandon reason
if one is provided.

It's possible for messages with the "autogenerated:gerrit:newPatchSet"
tag to also set labels, which wasn't previously supported. E.g.:

	Uploaded patch set 4: Run-TryBot+1.

	(1 comment)

Or:

	Uploaded patch set 5: Run-TryBot+1.

Update the code to handle these.

Some messages with the "autogenerated:gerrit:newPatchSet" tag have a
different format than previously expected:

	Patch Set 3: Commit message was updated.

I'm not aware that such messages could have inline comments, so handle
them by looking for a "Patch Set " prefix, and stop there. No need to do
more for now.

Previously, GitHub itself did not support leaving reactions on Pull
Request reviews. It was only possible to leave reactions on normal
comments and inline review comments. They've added that feature now,
so this change implements it accordingly in this package.

Reference: https://developer.github.com/v4/changelog/2019-01-11-schema-changes/.

In Gerrit, it's possible to publish inline comments on patchset push.
Such messages look like this:

	Uploaded patch set 2.

	(3 comments)

Parse and display such comments.

Use the more explicit project~id change ID format. It's not deprecated,
and lets us detect and return a not exist error when the project doesn't
match the CL.

Previously, just the numeric change ID was used. That format is
deprecated, and doesn't tell us when the project doesn't match the CL.

References:

• https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#change-id
• https://gerrit-review.googlesource.com/Documentation/config-gerrit.html#change.api.allowedIdentifier

Even though the package is a work in progress, it's still helpful
for it to have a description.

Reference: https://twitter.com/github/status/1086365048031854592.

This makes the page rendering code in serveIssues and serveChanges
methods more consistently high-level, and as a result, more readable.

It will make it easier to add new similar issues/changes pages that
display entries for import path patterns.

This change adds support for displaying issues/changes not just for
a single package at a time, but an arbitrary amount of packages that
match the specified import path pattern.

Reserved names "all", "std", and "cmd" are supported, and expand as
expected.

This change makes minor frontend tweaks to improve accessibility.

Also use margin-left instead of padding-left, to avoid making the
"Packages" link area become larger on the left side. Using margin-left
instead keeps the space on left unchanged, without expanding the link.

Regenerate with:

	go generate ./...

This fixes a gofmt formatting incompatibility with Go 1.11.

The issue https://golang.org/issue/21358 has been resolved upstream,
so there's no more need to use a temporary fork of the ctxhttp package.

Also regenerate assets to fix a gofmt formatting incompatibility
with Go 1.11.

This simplifies code, as fewer conversions are required.

Decide on and document the minimum supported macOS version as 10.13.
macOS 10.13 runs on the same hardware as 10.12, so anyone with 10.12
can update to 10.13 and use this package. I don't have access to older
versions of macOS to test with, nor do I have the bandwidth to support
them.

Also remove commented out sort code. It's normal and expected for
Gerrit IDs not to line up with created times. As documented at
https://godoc.org/golang.org/x/build/maintner#GerritCL.Number:

> Number is the CL number on the Gerrit server (e.g. 1, 2, 3). Gerrit CL
> numbers are sparse (CL N does not guarantee that CL N-1 exists) and
> Gerrit issues CL's out of order - it may issue CL N, then CL (N - 18),
> then CL (N - 40).

Also clean up and simplify some of the other code.

Still manually crafted in order to prototype and learn
about this space. It's still not completely clear how to
best integrate patch sets vs multiple commits, the commit
messages, and how git client fits into the picture.

The end result can be seen at
https://dmitri.shuralyov.com/gpu/mtl/...$changes/1.

Also remove unused commit header from diffMtlCommit1.

Still hard-coded mock data for now.

Update shurcool user to dmitshur.

It might be desirable for some users to be able to run a command that
outputs information about Metal devices without having to write code.
This is similar to utilities such as glfwinfo, glewinfo, etc.

This way, executing it with -help flag prints usage, rather than
running unconditionally.

Remove an unhelpful blank line.

Update Example_listDevices sample output to match output of a 2015 MBP
on macOS Mojave.

The goal of this change is to make it possible to use package mtl
to render to a window at interactive framerates (e.g., at 60 FPS,
assuming a 60 Hz display with vsync on). It adds the minimal API
that is needed.

A new movingtriangle example is added as a demonstration of this
functionality. It opens a window and renders a triangle that follows
the mouse cursor.

Much of the needed API comes from Core Animation, AppKit frameworks,
rather than Metal. Avoid adding that to mtl package; instead create
separate packages. For now, they are hidden in internal to avoid
committing to a public API and import path. After gaining more
confidence in the approach, they can be factored out and made public.

This helps with displaying large PRs that have over 100 timeline items
(e.g., https://github.com/neelance/go/pull/7).

The implementation is based the similar issues service ListTimeline,
see https://github.com/shurcooL/issues/commit/4081aa59e957752abbfc6b6fdab72c3bbc1c1dec.

The Go API tries to follow the Swift Metal API as closely as possible.

Add tests and examples.

Follows https://github.com/shurcooL/octicon/commit/c42b0e3b24d96976ecac81ef691662777b39ef64.

Follows https://github.com/shurcooL/octicon/commit/c42b0e3b24d96976ecac81ef691662777b39ef64.

Follows https://github.com/shurcooL/octicon/commit/c42b0e3b24d96976ecac81ef691662777b39ef64.

This is a more consistent naming scheme. The detail comes first, the
interface name comes last. Similar to limitedWriter, nopCloser, etc.

Previously, the review state wasn't correctly parsed when there
was more than 1 label (e.g., "Run-TryBot+1 Code-Review+2").

Example of an affected review is https://go-review.googlesource.com/c/go/+/112935#message-45e0d04e5f087880438b34c77b6b683f0beffaa3.

It should be beneficial to reduce bandwidth and speed up page load time.
Many dynamic pages will compress well (e.g., from 521 KB to 27.2 KB).
This is in large part because inline SVG are often repeated many times.

Only do so if the handler hasn't already taken care of compression.
This is determined by whether the Content-Encoding header is set
by the time WriteHeader is called.

Follows https://github.com/shurcooL/githubv4/commit/19298c78142b5fe80c2cdaa2091bc51cbc3a94fc.

Follows https://github.com/shurcooL/githubv4/commit/19298c78142b5fe80c2cdaa2091bc51cbc3a94fc.

Remove commented out code. It can be added when/if needed.

We need to fetch messages in Get method, so that counting them works.
Previously, len(chg.Messages) was always zero, and so was Replies as
a result.

Make project helper implementation simpler by making its error handling
path indented, and the normal execution path not indented.

Follows https://golang.org/issue/24836.

This check is now performed upstream in maintner,
so no need to do it here.

Follows https://golang.org/cl/107296.
Updates https://golang.org/issue/21984, https://golang.org/issue/22060, https://golang.org/issue/24875.

These checks are now performed upstream in maintner,
so no need to do it here.

Follows https://golang.org/cl/107296.
Updates https://golang.org/issue/21984, https://golang.org/issue/22060, https://golang.org/issue/24875.

This way, we detect a bad request and return an appropriate error
before starting anything else.

Make it more consistent across the services.

It happened once in the last 24 hours, but I haven't been able to
reproduce it since. Log it with details in case it happens again.

Updates https://golang.org/issue/21984.

It's sometimes desirable to see all CLs/PRs for a specific Go package.
This change makes that possible via the https://gochanges.org domain.

Improve naming consistency.

It's not completely read-only now, since it's possible to leave
reactions.

A CL is considered to not exist if it's private or if it has an empty
status (possible due to an upstream bug).

Updates https://golang.org/issue/22060.

This makes it easier to tell pages apart when multiple tabs are open,
or when viewing browsing history.

Use a little html/template to make this change easier.

Fixes issue 2.

These are minor changes, but they make the generated HTML look more
pretty and balanced.

Follows https://dmitri.shuralyov.com/service/change/...$commit/fc8c6aa79f17ce892e73e9f5422bb8b24becdd14.

This allows overriding where GitHub PRs can be viewed.

Similar to https://github.com/shurcooL/issues/commit/1cc2d579af3959bb9742445861b47a65a68c1a18.

Previously, only "golang.org/x" -> "x" direction was done. Now it goes
both ways.

For consistency and simplicity.

Previously, the import path was used directly as an issue title prefix.
This works for most import paths, but not for golang.org/x/... ones.
We need to map those to x/... prefixes.

Also simplify code in ParsePrefixedTitle.

The code to render a table of packages will be called more often in the
following commit. This refactor will make the upcoming diff smaller.

Rename isStandard parameter to give it a more readable name.

Sometimes it's helpful to be able to see a list of all packages (and
their number of open issues) at a glance.

Since they're all on one page, it's easy to use the browser's search
functionality to find a specific package or parent folder.

If Accept header is set to exactly "application/json", respond in JSON
format.

Some Go packages are not available for all OSes.

Doing a normal "go list" only lists packages that match the current
GOOS/GOARCH pair (darwin/amd64 in my case). So we run it with different
GOOS values to include all packages.

In case the highlighting algorithm encounters an error on some diff,
we don't want to abort entirely. Fall back to showing plain diff and
log the error for investigation.

This is an intermediate solution until the highlighting algorithm is
improved to handle the problematic case (which may take longer).

Helps https://dmitri.shuralyov.com/app/changes/...$issues/2.

go generate ./...

It was adding a listener for DOMContentLoaded event in code that runs
when that event has just fired, so the listener never ran.

Also clean up and simplify some relevant code.

Similar to https://github.com/shurcooL/issuesapp/commit/c25bd476f001893e3608cd5aa6b016760236ad2d.

Split IssueURL into IssueURL and IssueCommentURL.

Split PullRequestURL into PullRequestURL and PullRequestCommentURL.

Add PullRequestReviewURL and PullRequestReviewCommentURL.

Follows https://dmitri.shuralyov.com/service/change/...$commit/c4416e7845a6acd15a4c3ee4c0b71bd2b390ec42.

This is more robust.

It also removes the need to talk to real GitHub API while creating a
new service, which is undesirable during testing.

Analogous to https://github.com/shurcooL/issues/commit/adf13e46e3d966ef14ee08722b56b823cf5c3f3b.

go generate ./...

This way, pressing escape works even if you have a link selected (which
is often the case after clicking on an anchor). We avoid processing
unwanted keydown events because they'll be default prevented.

Add "keydown" event listener to body rather than document, because it's
sufficient and for consistency.

Because it's now applied as part of reactionsmenu code.

Follows shurcooL/frontend@e6633c2dc9c5d0f64511d5f12b86b0a331ef6cad.

Add and propagate an application lifetime context. It's cancelled on
SIGINT.

Make logging more simple and minimal.

Previously, it panicked. Now that I have a better how to deal with it,
add a comment describing the state. For now, skip such reviews. In the
future, can display them with a pending/draft style.

Regenerate with all golang.org/x/... packages in GOPATH, based on list
at https://github.com/golang/tools/blob/96caea41033df6f8c3974c845ab094f8ec3bd345/cmd/godoc/x.go#L27-L50.

This is a better location for setting the cursor. It fixes the problem
where the cursor was a pointer even when hovering over the empty space
where there's no reaction icon but blank space (when filter leaves fewer
reactions than the entire space for showing them).

Remove workaround for https://groups.google.com/forum/#!topic/golang-nuts/9AVyMP9C8Ac
since it has been fixed upstream in Go 1.10.

Remove workaround for https://groups.google.com/forum/#!topic/golang-nuts/9AVyMP9C8Ac
since it has been fixed upstream in Go 1.10.

Follows https://dmitri.shuralyov.com/service/change/...$commit/c96517b0fff082bd01bd62d8b020b7f7827cd63d.

Similar to https://github.com/shurcooL/issuesapp/commit/3bc17d8bc061b5a11eb287a91e23ef5dfcc38ea4.

Follows https://dmitri.shuralyov.com/service/change/...$commit/5b675ebb0b2bc6dd93ba2cedf6b4c7c9e0271de1
and https://dmitri.shuralyov.com/html/belt/...$commit/f6fb90ff73e49d9904a6a8a5561e437734a2ea57.

Follows https://dmitri.shuralyov.com/state/...$commit/28bcc343414c6adcd7b6911f9d0ef1ad6fbf30ae.

Similar to https://github.com/shurcooL/issues/commit/697ee8e877735feed6151525cad859327bfe40c4.

Follows https://dmitri.shuralyov.com/state/...$commit/28bcc343414c6adcd7b6911f9d0ef1ad6fbf30ae
and https://github.com/shurcooL/events/commit/25a0212309664cda69930a58f8369f24b9029812.

Regenerate.

Follows https://dmitri.shuralyov.com/service/change/...$commit/5f99232c79a97ad039852df6993da46e9cff24d2.

Change timeline item ID type from uint64 to string.

Previously, if the comment content had a wide preformatted code block,
it would cause the entire comment to get very wide.

Regenerate.

Regenerate.

Follows https://dmitri.shuralyov.com/service/change/...$commit/0005e9ba28e36d2df62c0e702668d1159f1fddcb.

This helps readability, and doesn't make the page appear too wide on
narrow mobile displays.

Helps https://dmitri.shuralyov.com/app/changes/...$issues/1.

Add unparsed messages as simple comments. This way, value of Replies
corresponds to actual number of messages.

Page size 100 is largest allowed.

Add full pagination later if/when needed.

This package has moved slightly.

Factor out Router from github.com/shurcooL/notifications/githubapi
package, so it can be more easily imported both by notifications/githubapi
and events/githubapi.

Add context parameter to enable some request-scoped flexibility over
routing.

It can't be set in Go 1.10 due to reflect changes.

Also switch from githubqlActor to githubqlUser because RequestedReviewer
union is known to be User or Team, so Actor interface is unnecessarily
broad.

References:

-	https://tip.golang.org/doc/go1.10#reflect
-	https://developer.github.com/v4/union/requestedreviewer/
-	https://developer.github.com/v4/interface/actor/

Detect ghost actors/users via them missing entirely, rather than
checking for zero DatabaseID. This is consistent with how GitHub
GraphQL returns them at this time.

Fix minor miscounting issue in reactions method.

Remove unneeded error return parameter from reactions method.

These changes help keep the code more consistent with
issues/githubapi package.

Regenerate ./assets.

Follows https://dmitri.shuralyov.com/service/change/...$commit/0493202ef5f73b299291d6aa0ad2f5338c197e46.

This was an accidental omission.

This is an initial implementation of a parser for the WOFF2 font
packaging format.

It is incomplete; further work will come later. The scope for this
milestone was to be able to parse .woff2 files for the needs of the
github.com/ConradIrwin/font/sfnt package.

At this time, the API is very low level and maps directly to the binary
format of the file, as described in its specification. This API is in
early development and is expected to change as further progress is made.

It successfully parses some Go font family .woff2 files that were
generated using the https://github.com/google/woff2 encoder
from the Go font source .ttf files located at
https://go.googlesource.com/image/+/master/font/gofont/ttfs/.

Add basic test coverage.

Helps https://github.com/ConradIrwin/font/issues/1.

Create and describe woff2 package.

Next commit will add an initial implementation.

It's needed because in some meta-services that unify multiple
underlying services, the ThreadType changes depending on the RepoSpec.

Improve local variable name.

Similar to https://github.com/shurcooL/issuesapp/commit/60bf33177c6943f244f14f81f145bc8b6c63f6cc.
Follows https://dmitri.shuralyov.com/service/change/...$commit/891fba5eb78bd1e1c421e6c7c422ccda350d246d.

It's needed because in some meta-services that unify multiple
underlying services, the ThreadType changes depending on the RepoSpec.

Similar to https://github.com/shurcooL/issuesapp/commit/60bf33177c6943f244f14f81f145bc8b6c63f6cc.

Also return no error and empty result in List, Count when repo spec
doesn't match.

They're internal HTML components and don't need to be exported.

Rename handler struct field to match the type name better. This was an
artifact copied from issuesapp.

go generate ./...

This is to avoid naming conflicts for upcoming package rename from
changes to change.

Update to current changes.Service interface.

This helps it render contextual information,
e.g., that depends on the current ChangeID.

Pass it directly rather than via a context value because this is
simpler and can be easily done since this is an unfrozen API.

Related to https://github.com/shurcooL/issuesapp/commit/e746af07544c3c630e745be0872f267cb1cec21e.

Otherwise, they were showing up as ghost users.

These are tiny packages for testing purposes only.

This is the first Go package that doesn't map 1:1 to a repository.
It's a subdirectory inside a repository. Support for that is not
implemented yet. This package will be used to help with that.

Rearrange services.

Rearrange services.

This simplifies things. No need to fetch them out of band.

There's no longer a clean distinction between comments and events.
There are other timeline item types that don't fit into either category
cleanly. Also, underlying implementations for various APIs are very
similar and have overlap. As a result, it makes sense to merge these
two methods into one.

There's no longer a clean distinction between comments and events.
There are other timeline item types that don't fit into either category
cleanly. Also, underlying implementations for various APIs are very
similar and have overlap. As a result, it makes sense to merge these
two methods into one.

Keep only read behavior. This greatly simplifies the code and allows
faster development of changesapp-specific features.

Write behavior will be worked in the future, after read behavior is
fully complete.

Remove ListCommitsOptions from ListCommits. Expected usage is to always
get all commits, then find the one you're interested in. This is what's
needed to implement prev/next commit buttons, and more closely matches
what's returned by 3rd party APIs.

The button styling can be improved; to be done later.

Remove ListCommitsOptions from ListCommits. Expected usage is to always
get all commits, then find the one you're interested in. This is what's
needed to implement prev/next commit buttons, and more closely matches
what's returned by 3rd party APIs.

The button styling can be improved; to be done later.

GitHub notifications for PRs have subject type "PullRequest".

These are not actual comments, they add noise. Perhaps we can display
them as events in the future.

Add GetDiff method to it.

Rather than "not found", which is misleading and makes it look like the
implementation isn't working (when in fact there is no implementation).

Simplify some code by indenting the uncommon path.

The package has moved. It was never pushed to the previous remote, all
development was done locally, so it can't have any external users.

It's not needed and not used; issuesapp provides its own anchor styles
where needed.

	name     time/op
	Parse-8  629ns ± 3%

The performance of strings.Split on a 1-byte length string is very
good (optional CPU features and assembly are employed), and a naive
custom implementation is significantly slower (1100-2500 ns/op).

Enough time has passed since the API was created, and so far, I have
not had desires to change it, nor has anyone else suggested any API
improvements. It's likely going to stay as is, so remove the comment.
If there are good change ideas in the future, it can still be
considered. But the comment was meant for the very early days of the
package's existence, and has outlived its usefulness.

On Windows, a file that hasn't been gofmt'ed can have \r\n line endings.
Though rare and unusual, it's still a valid .go file and needs to be
supported.

The performance cost is not significant compared to the entire task.

	name         old time/op  new time/op  delta
	ParseFile-8  32.4µs ± 1%  32.4µs ± 1%   ~     (p=1.000 n=10+10)

Fixes https://github.com/shurcooL/go/issues/30.

Update docs to be more accurate.

Add cmd/gerritchanges, a program to serve Gerrit changes.

This makes it possible to use this package in contexts where the .go
file is in memory or otherwise not available on disk.

For now, keep ParseFile around as a trivial helper. If it ends up being
not used in the wild much, perhaps it could be deprecated/removed later.

Fixes https://github.com/shurcooL/go/issues/31.

The specification proposal at golang.org/issue/13560 has changed.
This updates the parser implementation for the latest spec
as described at https://golang.org/s/generatedcode:

	Generated files are marked by a line of text that matches
	the regular expression, in Go syntax:

		^// Code generated .* DO NOT EDIT\.$

	The .* means the tool can put whatever folderol it wants in there,
	but the comment must be a single line and must start with Code generated
	and end with DO NOT EDIT., with a period.

	The text may appear anywhere in the file.

The new implementation for this spec is simpler. It uses bufio.Reader
and ReadBytes. The performance can be optimized further by using lower
level IO primitives and allocating less, but the first priority is
getting a correct parser out for the latest spec. It can be optimized
later as needed.

The main cause of inefficiency is having to read the entire file,
without being able to stop early, because the new specification
allows the comment to appear anywhere in the file.

GitHub-Pull-Request: https://github.com/shurcooL/go/pull/29

This new package contains an initial attempt at implementing a parser
for the currently proposed specification for generated disclaimer
comment in golang.org/issue/13560.