implab/gradle-mercurial-plugin Commit - r1:193d6f38df6e

added preReleasePolicy, stagingBookmark, releaseBookmark to the extension, added documentation....

cin -

r1:193d6f38df6e v1.0.0 default

parent child

Context file:

r1:193d6f38df6e

Collapse all files

.vscode/settings.json created 644 +3 0

@@ -0,0 +1,3
	1	{
	2	"java.configuration.updateBuildConfiguration": "automatic"
	3	} No newline at end of file

gradle.properties created 644 +2 0

@@ -0,0 +1,2
	1	group=org.implab.gradle
	2	version=1.0.0 No newline at end of file

gradle/wrapper/gradle-wrapper.jar created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gradle/wrapper/gradle-wrapper.properties created 644 +5 0

@@ -0,0 +1,5
	1	distributionBase=GRADLE_USER_HOME
	2	distributionPath=wrapper/dists
	3	distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
	4	zipStoreBase=GRADLE_USER_HOME
	5	zipStorePath=wrapper/dists

readme.md created 644 +120 0

@@ -0,0 +1,120
	1	# Mercurial build integration
	2
	3	## SYNOPSIS
	4
	5	```groovy
	6
	7	plugins {
	8	id 'org.implab.gradle-mercurial' version '1.0'
	9	}
	10
	11	mercurial {
	12	releaseBookmark = 'prod'
	13
	14	preReleasePolicy { it
	15	// this is the default behaviour
	16	.addPatch(1)
	17	.withPreRelease('snapshot')
	18	.withMeta('changeset')
	19	}
	20
	21	// get version from repository and apply it to the project
	22	applyVersioningPolicy()
	23	}
	24
	25	```
	26
	27	## DESCRIPTION
	28
	29	### `semver(versionString)`
	30
	31	Parses the specified version string and returns the semantic version object
	32
	33	### `mercurial(Closure configure)`
	34
	35	The extension added by the plugin to the project. Apply this plugin to the
	36	root project and use the `mercurial { ... }` section to configure the
	37	versioning.
	38
	39	See the description below for more details about settings.
	40
	41	#### `hgCmd`
	42
	43	The command which will be executed to perform the mercurial commands.
	44	The default value is `hg`.
	45
	46	#### `outputCharset`
	47
	48	The charset for the `hgCmd` output, this property defaults
	49	to the default charset of the operating system.
	50
	51	#### `hg(...args)`
	52
	53	Executes the mercurial command, returns the command output as text.
	54
	55	#### `workspaceInfo` (read-only)
	56
	57	Returns the information about current workspace, see description
	58	below for details.
	59
	60	#### `workspaceVersion`
	61
	62	Returns the semantic version obtained from the repository. Querying
	63	this property will lead querying the workspace info.
	64
	65	#### `applyVersioningPolicy()`
	66
	67	Reads the workspace information and sets the version of the project
	68	according to settings.
	69
	70	If the version was specified using properties, then the specified
	71	version will take preceding over the calculated one.
	72
	73	#### `preReleasePolicy(Closure<SemVersion> config)`
	74
	75	The closure which is used to calculate the version of the project
	76	when the current commit isn't marked with a version tag.
	77
	78	The default behaviour is to increment the patch version and
	79	to set the pre-release suffix to `'snapshot'`.
	80
	81	### `WorkspaceInfo`
	82
	83	This class encapsulates information about the current workspace.
	84	All properties are read-only.
	85
	86	#### `versionTag`
	87
	88	The original version tag from the repository before parsing.
	89
	90	#### `changeSet`
	91
	92	The changeset id of the current workspace.
	93
	94	#### `versionDistance`
	95
	96	The distance in commits to the versionTag
	97
	98	#### `branch`
	99
	100	The name of the current sources branch.
	101
	102	#### `isDirty`
	103
	104	This flag indicates uncommited changes to the workspace. This flag is useful
	105	to control some pipelines which run locally on developer machines.
	106
	107	## TASKS
	108
	109	### `release`
	110
	111	Marks this commit with current version and pre-release suffix removed and
	112	moves the `release` bookmark to it.
	113
	114	### `staging`
	115
	116	Marks this commit with current version and moves the `staging` bookmark to it.
	117
	118	### `printVersion`
	119
	120	Prints the current version.

mercurial/build.gradle +11 -2

             plugins {
                 id "java-gradle-plugin"
+                id "com.gradle.plugin-publish" version "0.16.0"
             }
             repositories {
             	mavenCentral()
             }
             gradlePlugin {
             	plugins {
-            		containerPlugin {
+            		mercurialPlugin {
             			id = 'org.implab.gradle-mercurial'
             			implementationClass = 'org.implab.gradle.mercurial.MercurialPlugin'
+                        displayName = "Integrates mercurial into the build script"
+                        description = 'Automatically calculates version using tags. Simple wrapper around cli.'
             		}
             	}
             }
+            pluginBundle {
+                website = 'https://code.implab.org/implab/gradle-mercurial-plugin'
+                vcsUrl = 'https://code.implab.org/implab/gradle-mercurial-plugin'
+                tags = ['hg', 'mercurial']
+            }

mercurial/src/main/java/org/implab/gradle/Utils.java +9 -3

                     }).start();
                 }
-                public static String execCmd(List<String> args, String charset) throws IOException, InterruptedException, Exception {
+                public static String execCmd(List<String> args, String charset) {
                     if (args == null || args.size() == 0)
                         throw new IllegalArgumentException();
                     ProcessBuilder builder = new ProcessBuilder(args);
-                    Process p = builder.start();
+                    Process p;
+                    try {
+                        p = builder.start();
                         String output = readAll(p.getInputStream(), charset);
                         int code = p.waitFor();
                         if (code != 0)
-                        throw new Exception(String.format("The process `%s` failed with code: %s", args.get(0), code));
+                            throw new RuntimeException(String.format("The process `%s` failed with code: %s", args.get(0), code));
                         return output;
+                    } catch (IOException | InterruptedException e) {
+                        throw new RuntimeException(String.format("Failed to execute `%s`", args.get(0)), e);
+                    }
                 }
                                 public boolean handles(Class<?> type) {
                                     return (File.class == type);
                                 }
                                 public Object convert(Object value, String key) {
                                     return ((File) value).getPath();
                                 }

mercurial/src/main/java/org/implab/gradle/mercurial/MercurialExtension.java +73 -16

             import java.util.List;
             import java.util.Objects;
             import java.util.Optional;
+            import java.util.function.Function;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             import org.gradle.api.Project;
             import org.implab.gradle.Utils;
+            import groovy.lang.Closure;
             public class MercurialExtension {
                 private static final String COMMIT_INFO_TEMPLATE = "{latesttag('re:^v') % '{ifeq(tag,'null','',tag)}:{distance}'}:{branch}:{node|short}";
                 private String hgCmd = "hg";
+                private String stagingBookmark = "staging";
+                private String releaseBookmark = "prod";
                 private SemVersion defaultWorkspaceVersion = new SemVersion(0, 0, 1, "dev", null);
+                private Function<SemVersion, SemVersion> preReleasePolicy;
                 public MercurialExtension(Project project) {
                     Objects.requireNonNull(project);
                     this.project = project;
                 }
-                public String hg(String... args) throws Exception {
+                public String hg(String... args) {
                     List<String> commandLine = new ArrayList<>();
                     commandLine.add(hgCmd);
                     Collections.addAll(commandLine, args);
                     return Utils.execCmd(commandLine, outputCharset.name());
                 }
+                public String getReleaseBookmark() {
+                    return releaseBookmark;
+                }
+                public void setReleaseBookmark(String value) {
+                    if(value == null)
+                        throw new IllegalArgumentException();
+                    releaseBookmark = value;
+                }
+                public String getStagingBookmark() {
+                    return stagingBookmark;
+                }
+                public void setStagingBookmark(String value) {
+                    if(value == null)
+                        throw new IllegalArgumentException();
+                    stagingBookmark = value;
+                }
                 public Charset getOutputCharset() {
                     return outputCharset;
                 }
                     this.hgCmd = hgCmd;
                 }
-                public WorkspaceInfo getWorkspaceInfo() throws Exception {
+                public WorkspaceInfo getWorkspaceInfo() {
                     if (workspaceInfo == null)
                         workspaceInfo = loadWorkspaceInfo();
                     return workspaceInfo;
                 }
-                public SemVersion getWorkspaceVersion() throws Exception {
+                public SemVersion getWorkspaceVersion() {
                     return tryParseVersion(getWorkspaceInfo().getVersionTag()).orElse(defaultWorkspaceVersion);
                 }
-                public void applyVersioningPolicy() throws Exception {
+                private SemVersion defaultPreReleasePolicy(SemVersion version) {
-                    Object version = project.getVersion();
-                    if (version == null || version.toString().isBlank() || version.toString().equalsIgnoreCase(Project.DEFAULT_VERSION)) {
-                        int distance = getWorkspaceInfo().getVersionDistance();
                     String changeset = getWorkspaceInfo().getChangeset();
-                        project.setVersion(
+                    return version.addPatch(1).withPreRelease("snapshot").withMeta(changeset);
-                            distance> 0 ?
-                                getWorkspaceVersion().addPatch(distance).suffix("snapshot").meta(changeset) :
-                                getWorkspaceVersion()
+                public void preReleasePolicy(Closure<SemVersion> policy) {
-                        );
+                    if (policy == null)
+                        throw new IllegalArgumentException();
+                    this.preReleasePolicy = x -> {
+                        policy.setDelegate(getWorkspaceInfo());
+                        policy.setResolveStrategy(Closure.DELEGATE_FIRST);
+                        return policy.call(x);
+                    };
+                }
+                public void preReleasePolicy(Function<SemVersion, SemVersion> policy) {
+                    if (policy == null)
+                        throw new IllegalArgumentException();
+                    this.preReleasePolicy = policy;
+                }
+                public void applyVersioningPolicy() {
+                    Object version = project.getVersion();
+                    if (version == null || version.toString().isBlank()
+                            || version.toString().equalsIgnoreCase(Project.DEFAULT_VERSION)) {
+                        // if the version isn't specified
+                        int distance = getWorkspaceInfo().getVersionDistance();
+                        // the current workspace is not tagged with the version
+                        if (distance > 0) {
+                            SemVersion preReleaseVersion = Optional.ofNullable(preReleasePolicy)
+                                    .orElse(this::defaultPreReleasePolicy)
+                                    .apply(getWorkspaceVersion());
+                            project.setVersion(preReleaseVersion);
+                        } else {
+                            project.setVersion(getWorkspaceVersion());
+                        }
                     } else {
                         project.setVersion(SemVersion.toSemVersion(version, false));
                     }
                 }
-                String[] queryLogInfo() throws Exception {
+                String[] queryLogInfo() {
                     return hg("log", "-r", ".", "--template", COMMIT_INFO_TEMPLATE).split(":");
                 }
-                WorkspaceInfo loadWorkspaceInfo() throws Exception {
+                WorkspaceInfo loadWorkspaceInfo() {
                     boolean isDirty = checkIsDirty();
                     String[] info = queryLogInfo();
                     return new WorkspaceInfo(info[0], Integer.parseInt(info[1]), info[2], info[3], isDirty);
                 }
-                boolean checkIsDirty() throws Exception {
+                boolean checkIsDirty() {
                     return !hg("status", "-mard").isBlank();
                 }
                     return isMatch ? SemVersion.tryParseLax(m.group(1)) : Optional.empty();
                 }
             }

mercurial/src/main/java/org/implab/gradle/mercurial/MercurialPlugin.java +7 -6

                     project.getTasks().register("printVersion", t -> {
                         t.doLast(t2 -> {
+                            t2.getLogger().quiet("workspace: {}", mercurialExtension.getWorkspaceInfo());
                             t2.getLogger().quiet("version: {}", project.getVersion());
                         });
                     });
                                     throw new Exception("The workspace is dirty, you need to commit changes first");
                                 SemVersion version = (SemVersion) project.getVersion();
-                                SemVersion nextVersion = version.release();
+                                SemVersion nextVersion = version.withNoSuffix();
-                                self.getLogger().quiet("release {} -> {}", version, nextVersion);
+                                self.getLogger().quiet("{} {} -> {}", mercurialExtension.getReleaseBookmark(), version, nextVersion);
-                                hgBookmarkTask.get().getBookmarks().add("prod");
+                                hgBookmarkTask.get().getBookmarks().add(mercurialExtension.getReleaseBookmark());
                                 hgTagTask.get().getTags().add("v" + nextVersion.toString());
                             } catch (Exception e) {
                                 throw new TaskExecutionException(self, e);
                                     throw new Exception("The workspace is dirty, you need to commit changes first");
                                 SemVersion version = (SemVersion) project.getVersion();
-                                SemVersion nextVersion = version.release().suffix("rc");
+                                SemVersion nextVersion = version.withNoSuffix().withPreRelease("rc");
-                                self.getLogger().quiet("staging {} -> {}", version, nextVersion);
+                                self.getLogger().quiet("{} {} -> {}", mercurialExtension.getStagingBookmark(), version, nextVersion);
-                                hgBookmarkTask.get().getBookmarks().add("staging");
+                                hgBookmarkTask.get().getBookmarks().add(mercurialExtension.getStagingBookmark());
                                 hgTagTask.get().getTags().add("v" + nextVersion.toString());
                             } catch (Exception e) {
                                 throw new TaskExecutionException(self, e);

mercurial/src/main/java/org/implab/gradle/mercurial/SemVersion.java +79 -60

             import javax.annotation.Nonnull;
+            /**
+             * Semantic version object.
+             *
+             * <p>
+             * This is a readonly version record which follows general rules of
+             * semantic versioning. The object is serializable and can be used as
+             * input property value for build tasks.
+             */
             public class SemVersion implements Serializable, Comparable<SemVersion> {
                 private static final long serialVersionUID = 1L;
                 private static Pattern semVerLaxPattern = Pattern.compile(
                         "^(0|[1-9]\\d*)(?:\\.(0|[1-9]\\d*)(?:\\.(0|[1-9]\\d*))?)?(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$");
-                private int major;
+                private final int major;
-                private int minor;
+                private final int minor;
-                private int patch;
+                private final int patch;
-                private String suffix;
+                private final String preRelease;
+                private final String meta;
-                private String meta;
+                /** Creates the new and empty version */
                 public SemVersion() {
+                    this(0, 0, 0, null, null);
                 }
-                public SemVersion(int major, int minor, int patch, String suffix, String meta) {
+                /** Creates the version object with the specified values */
+                public SemVersion(int major, int minor, int patch, String preRelease, String meta) {
                     this.major = major;
                     this.minor = minor;
                     this.patch = patch;
-                    this.suffix = suffix;
+                    this.preRelease = preRelease;
                     this.meta = meta;
                 }
+                /** Creates the version object with the specified values */
                 public SemVersion(int major, int minor, int patch) {
                     this(major, minor, patch, null, null);
                 }
-                public SemVersion(SemVersion src) {
+                /** Returns the major part of the version */
-                    this(src.major, src.minor, src.patch, src.suffix, src.meta);
                 public int getMajor() {
                     return major;
                 }
-                public void setMajor(int major) {
+                /** Returns the minor part of the version */
-                    this.major = major;
                 public int getMinor() {
                     return minor;
                 }
-                public void setMinor(int minor) {
+                /** Returns the patch part of the version */
-                    this.minor = minor;
                 public int getPatch() {
                     return patch;
                 }
-                public void setPatch(int patch) {
+                /** Gets the optional pre-release version part */
-                    this.patch = patch;
+                public Optional<String> getPreRelease() {
+                    return Optional.ofNullable(preRelease);
-                public Optional<String> getSuffix() {
-                    return Optional.ofNullable(suffix);
-                public void setSuffix(String suffix) {
-                    this.suffix = suffix;
                 }
                 public Optional<String> getMeta() {
                     return Optional.ofNullable(meta);
                 }
-                public void setMeta(String meta) {
-                    this.meta = meta;
                 public boolean isRelease() {
-                    return getSuffix().isEmpty();
+                    return getPreRelease().isEmpty();
                 }
                 @Override
                     StringBuilder sb = new StringBuilder();
                     sb.append(major).append(".").append(minor).append(".").append(patch);
-                    getSuffix().ifPresent(s -> sb.append("-").append(s));
+                    getPreRelease().ifPresent(s -> sb.append("-").append(s));
                     getMeta().ifPresent(m -> sb.append("+").append(m));
                     return sb.toString();
                         return res;
                     res = Integer.compare(patch, other.patch);
-                    return getSuffix()
+                    return getPreRelease()
-                            // if we have suffix, chech another suffix, if there is no another suffix
+                            // if we have suffix, check the other version suffix,
-                            // then another version is bigger: 1.0.0-rc < 1.0.0
+                            // if the other has no suffix then it's greater.
-                            .map(s1 -> other.getSuffix().map(s2 -> s1.compareTo(s2)).orElse(-1))
+                            // 1.0.0-rc < 1.0.0
+                            .map(s1 -> other.getPreRelease().map(s2 -> s1.compareTo(s2)).orElse(-1))
                             // if we don't have the suffix
-                            .orElse(other.getSuffix().isPresent() ? 1 : 0);
+                            .orElse(other.getPreRelease().isPresent() ? 1 : 0);
                 }
-                public SemVersion release() {
+                /** Removes the tag (pre-release and meta information) */
+                public SemVersion withNoSuffix() {
                     return new SemVersion(major, minor, patch, null, null);
                 }
-                public SemVersion suffix(String suffix) {
+                /** Sets the specified suffix leaving other parts unchanged */
-                    return new SemVersion(major, minor, patch, suffix, meta);
+                public SemVersion withPreRelease(String preRelease) {
+                    return new SemVersion(major, minor, patch, preRelease, meta);
                 }
-                public SemVersion suffix() {
+                /** Removes pre-release information leaving other parts unchanged */
+                public SemVersion withNoPreRelease() {
                     return new SemVersion(major, minor, patch, null, meta);
                 }
-                public SemVersion meta(String meta) {
+                /** Sets the specified build metadata */
-                    return new SemVersion(major, minor, patch, suffix, meta);
+                public SemVersion withMeta(String meta) {
+                    return new SemVersion(major, minor, patch, preRelease, meta);
                 }
-                public SemVersion meta() {
+                /** Removes the build metadata from the version */
-                    return new SemVersion(major, minor, patch, suffix, null);
+                public SemVersion withNoMeta() {
+                    return new SemVersion(major, minor, patch, preRelease, null);
                 }
-                public SemVersion patch(int patch) {
+                /** Sets the specified patch version */
-                    return new SemVersion(major, minor, patch, suffix, meta);
+                public SemVersion withPatch(int patch) {
+                    return new SemVersion(major, minor, patch, preRelease, meta);
                 }
-                public SemVersion minor(int minor) {
+                /** Sets the specified minor version */
-                    return new SemVersion(major, minor, patch, suffix, meta);
+                public SemVersion withMinor(int minor) {
+                    return new SemVersion(major, minor, patch, preRelease, meta);
                 }
-                public SemVersion major(int major) {
+                /** Sets the specified major version */
-                    return new SemVersion(major, minor, patch, suffix, meta);
+                public SemVersion withMajor(int major) {
+                    return new SemVersion(major, minor, patch, preRelease, meta);
                 }
+                /** Adds the specified number to the patch version */
                 public SemVersion addPatch(int number) {
-                    return new SemVersion(major, minor, patch + number, suffix, meta);
+                    return new SemVersion(major, minor, patch + number, preRelease, meta);
                 }
+                /** Adds the specified number to the minor version */
                 public SemVersion addMinor(int number) {
-                    return new SemVersion(major, minor + number, patch, suffix, meta);
+                    return new SemVersion(major, minor + number, patch, preRelease, meta);
                 }
+                /** Adds the specified number to the major version */
                 public SemVersion addMajor(int number) {
-                    return new SemVersion(major + number, minor, patch, suffix, meta);
+                    return new SemVersion(major + number, minor, patch, preRelease, meta);
                 }
+                /** Generated the next minor version by incrementing the minor version,
+                 * setting the patch version to 0 and removing the pre-release information.
+                 * The build metadata is left unchanged.
+                 *
+                 * <p>Use this method to publish next minor version.
+                 */
                 public SemVersion nextMinor() {
                     return new SemVersion(major, minor + 1, 0, null, meta);
                 }
+                /** Generated the next minor version by incrementing the major version,
+                 * setting the minor version and the patch to 0 and removing the
+                 * pre-release information. The build metadata is left unchanged.
+                 *
+                 * <p>Use this method to publish next major version.
+                 */
                 public SemVersion nextMajor() {
                     return new SemVersion(major + 1, 0, 0, null, meta);
                 }
+                /** Parses the version string. */
                 public static Optional<SemVersion> tryParse(@Nonnull String str) {
                     Objects.requireNonNull(str);
                             : Optional.empty();
                 }
+                /** Parses the version string. When  */
                 public static Optional<SemVersion> tryParseLax(@Nonnull String str) {
                     Objects.requireNonNull(str);
                     if (value == null) {
                         return new SemVersion();
                     } else if (value instanceof SemVersion) {
-                        return new SemVersion((SemVersion) value);
+                        return (SemVersion) value;
                     } else {
                         Optional<SemVersion> semver = strict ? tryParse(value.toString()) : tryParseLax(value.toString());
-                        return semver.orElseThrow(() -> new IllegalArgumentException(String.format("Failed to parse semver '%s', strict=%s", value, strict)));
+                        return semver.orElseThrow(() -> new IllegalArgumentException(
+                                String.format("Failed to parse semver '%s', strict=%s", value, strict)));
                     }
                 }

mercurial/src/main/java/org/implab/gradle/mercurial/tasks/HgBookmark.java +2 -2

             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.Property;
+            import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.Utils;
             import org.implab.gradle.mercurial.MercurialExtension;
-            import groovy.transform.Internal;
             public class HgBookmark extends DefaultTask {
                 private final Property<String> cliCmd;
                 private String commandOutput;
+                @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }

mercurial/src/main/java/org/implab/gradle/mercurial/tasks/HgTag.java +3 -6

             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.Property;
-            import org.gradle.api.tasks.Input;
+            import org.gradle.api.tasks.Internal;
-            import org.gradle.api.tasks.SkipWhenEmpty;
             import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.Utils;
             import org.implab.gradle.mercurial.MercurialExtension;
-            import groovy.transform.Internal;
             public class HgTag extends DefaultTask {
                 private final Property<String> cliCmd;
                 private String commandOutput;
+                @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }
                     return commandOutput;
                 }
-                @Input
+                @Internal
-                @SkipWhenEmpty
                 public ListProperty<String> getTags() {
                     return tags;
                 }

mercurial/src/main/java/org/implab/gradle/mercurial/tasks/HgTask.java +3 0

             import org.gradle.api.DefaultTask;
             import org.gradle.api.provider.Property;
             import org.gradle.api.provider.Provider;
+            import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.Utils;
             import org.implab.gradle.mercurial.MercurialExtension;
                 private String commandOutput;
+                @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }
                 }
+                @Internal
                 public String getCommandOutput() {
                     return commandOutput;
                 }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages