implab/gradle-mercurial-plugin Commit - r4:645e2e6a0875

java/org/implab/gradle/Utils rmoved to org/implab/gradle/mercurial/Utils to resolve conflicts with other plugins

cin -

r4:645e2e6a0875 v1.0.1 default

parent child

Context file:

r4:645e2e6a0875

Collapse all files

gradle.properties +1 -1

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

mercurial/src/main/java/org/implab/gradle/mercurial/MercurialExtension.java 0 -1

             package org.implab.gradle.mercurial;
             import java.nio.charset.Charset;
             import java.util.ArrayList;
             import java.util.Collections;
             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 static final Pattern versionPattern = Pattern.compile("^(?:v[\\-_\\.]?)?(.*)");
                 private final Project project;
                 private Charset outputCharset = Charset.defaultCharset();
                 private WorkspaceInfo workspaceInfo;
                 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) {
                     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;
                 }
                 public void setOutputCharset(Charset outputCharset) {
                     this.outputCharset = Optional.ofNullable(outputCharset).orElseGet(Charset::defaultCharset);
                 }
                 public void setOutputCharset(String outputCharset) {
                     this.outputCharset = Optional.ofNullable(outputCharset).map(x -> Charset.forName(x))
                             .orElseGet(Charset::defaultCharset);
                 }
                 public String getHgCmd() {
                     return hgCmd;
                 }
                 public void setHgCmd(String hgCmd) {
                     this.hgCmd = hgCmd;
                 }
                 public WorkspaceInfo getWorkspaceInfo() {
                     if (workspaceInfo == null)
                         workspaceInfo = loadWorkspaceInfo();
                     return workspaceInfo;
                 }
                 public SemVersion getWorkspaceVersion() {
                     return tryParseVersion(getWorkspaceInfo().getVersionTag()).orElse(defaultWorkspaceVersion);
                 }
                 private SemVersion defaultPreReleasePolicy(SemVersion version) {
                     String changeset = getWorkspaceInfo().getChangeset();
                     return version.addPatch(1).withPreRelease("snapshot").withMeta(changeset);
                 }
                 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() {
                     return hg("log", "-r", ".", "--template", COMMIT_INFO_TEMPLATE).split(":");
                 }
                 WorkspaceInfo loadWorkspaceInfo() {
                     boolean isDirty = checkIsDirty();
                     String[] info = queryLogInfo();
                     return new WorkspaceInfo(info[0], Integer.parseInt(info[1]), info[2], info[3], isDirty);
                 }
                 boolean checkIsDirty() {
                     return !hg("status", "-mard").isBlank();
                 }
                 Optional<SemVersion> tryParseVersion(String version) {
                     if (version == null)
                         return Optional.empty();
                     Matcher m = versionPattern.matcher(version);
                     boolean isMatch = m.matches();
                     return isMatch ? SemVersion.tryParseLax(m.group(1)) : Optional.empty();
                 }
             }

mercurial/src/main/java/org/implab/gradle/mercurial/Utils.java ~~mercurial/src/main/java/org/implab/gradle/Utils.java~~ renamed +1 -1

-            package org.implab.gradle;
+            package org.implab.gradle.mercurial;
             import java.io.ByteArrayOutputStream;
             import java.io.Closeable;
             import java.io.File;
             import java.io.FileOutputStream;
             import java.io.IOException;
             import java.io.InputStream;
             import java.io.OutputStream;
             import java.util.List;
             import java.util.Scanner;
             import org.gradle.api.Action;
             import groovy.json.JsonGenerator;
             import groovy.json.JsonOutput;
             import groovy.json.JsonGenerator.Converter;
             import groovy.lang.Closure;
             public final class Utils {
                 public static void redirectIO(final InputStream src, final Action<String> consumer) {
                     new Thread(() -> {
                         try (Scanner sc = new Scanner(src)) {
                             while (sc.hasNextLine()) {
                                 consumer.execute(sc.nextLine());
                             }
                         }
                     }).start();
                 }
                 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;
                     try {
                         p = builder.start();
                         String output = readAll(p.getInputStream(), charset);
                         int code = p.waitFor();
                         if (code != 0)
                             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 static void redirectIO(final InputStream src, final File file) {
                     new Thread(() -> {
                         try (OutputStream out = new FileOutputStream(file)) {
                             src.transferTo(out);
                         } catch (Exception e) {
                             // silence!
                         }
                     }).start();
                 }
                 public static String readAll(final InputStream src) throws IOException {
                     ByteArrayOutputStream out = new ByteArrayOutputStream();
                     src.transferTo(out);
                     return out.toString();
                 }
                 public static String readAll(final InputStream src, String charset) throws IOException {
                     ByteArrayOutputStream out = new ByteArrayOutputStream();
                     src.transferTo(out);
                     return out.toString(charset);
                 }
                 public static JsonGenerator createDefaultJsonGenerator() {
                     return new JsonGenerator.Options()
                             .excludeNulls()
                             .addConverter(new Converter() {
                                 public boolean handles(Class<?> type) {
                                     return (File.class == type);
                                 }
                                 public Object convert(Object value, String key) {
                                     return ((File) value).getPath();
                                 }
                             })
                             .build();
                 }
                 public static void closeSilent(Closeable handle) {
                     try {
                         handle.close();
                     } catch (Exception e) {
                         // silence!
                     }
                 }
                 public static String toJsonPretty(Object value) {
                     return JsonOutput.prettyPrint(createDefaultJsonGenerator().toJson(value));
                 }
                 public static boolean isNullOrEmptyString(String value) {
                     return (value == null || value.length() == 0);
                 }
                 public static <T> Action<T> wrapClosure(Closure<?> closure) {
                     return x -> {
                         closure.setDelegate(x);
                         closure.setResolveStrategy(Closure.DELEGATE_FIRST);
                         closure.call(x);
                     };
                 }
             }

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

             package org.implab.gradle.mercurial.tasks;
             import java.io.IOException;
             import java.util.ArrayList;
             import java.util.List;
             import javax.inject.Inject;
             import org.gradle.api.DefaultTask;
             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 org.implab.gradle.mercurial.Utils;
             public class HgBookmark extends DefaultTask {
                 private final Property<String> cliCmd;
                 private final Property<Boolean> inactive;
                 private final Property<Boolean> force;
                 private final ListProperty<String> bookmarks;
                 private String commandOutput;
                 @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }
                 @Inject
                 public HgBookmark(ObjectFactory factory) {
                     cliCmd = factory.property(String.class);
                     inactive = factory.property(Boolean.class);
                     force = factory.property(Boolean.class);
                     bookmarks = factory.listProperty(String.class);
                     cliCmd.convention(getMercurialExtension().getHgCmd());
                     onlyIf(t -> !getBookmarks().get().isEmpty());
                 }
                 @Internal
                 public Property<Boolean> getInactive() {
                     return inactive;
                 }
                 @Internal
                 public Property<Boolean> getForce() {
                     return force;
                 }
                 @Internal
                 public String getCommandOutput() {
                     return commandOutput;
                 }
                 @Internal
                 public ListProperty<String> getBookmarks() {
                     return bookmarks;
                 }
                 @TaskAction
                 public void Run() throws IOException, InterruptedException, Exception {
                     List<String> commandLine = new ArrayList<>();
                     commandLine.add(cliCmd.get());
                     commandLine.add("bookmark");
                     if(inactive.isPresent())
                         commandLine.add("-i");
                     if(force.isPresent())
                         commandLine.add("-f");
                     commandLine.addAll(bookmarks.get());
                     getLogger().info("Starting: {}", commandLine);
                     commandOutput = Utils.execCmd(commandLine, getMercurialExtension().getOutputCharset().name());
                 }
             }

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

             package org.implab.gradle.mercurial.tasks;
             import java.io.IOException;
             import java.util.ArrayList;
             import java.util.List;
             import javax.inject.Inject;
             import org.gradle.api.DefaultTask;
             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 org.implab.gradle.mercurial.Utils;
             public class HgTag extends DefaultTask {
                 private final Property<String> cliCmd;
                 private final Property<Boolean> force;
                 private final ListProperty<String> tags;
                 private String commandOutput;
                 @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }
                 @Inject
                 public HgTag(ObjectFactory factory) {
                     cliCmd = factory.property(String.class);
                     force = factory.property(Boolean.class);
                     tags = factory.listProperty(String.class);
                     cliCmd.convention(getMercurialExtension().getHgCmd());
                     onlyIf(t -> !getTags().get().isEmpty());
                 }
                 @Internal
                 public Property<Boolean> getForce() {
                     return force;
                 }
                 @Internal
                 public String getCommandOutput() {
                     return commandOutput;
                 }
                 @Internal
                 public ListProperty<String> getTags() {
                     return tags;
                 }
                 @TaskAction
                 public void Run() throws IOException, InterruptedException, Exception {
                     List<String> commandLine = new ArrayList<>();
                     commandLine.add(cliCmd.get());
                     commandLine.add("tag");
                     if(force.isPresent())
                         commandLine.add("-f");
                     commandLine.addAll(tags.get());
                     getLogger().info("Starting: {}", commandLine);
                     commandOutput = Utils.execCmd(commandLine, getMercurialExtension().getOutputCharset().name());
                 }
             }

mercurial/src/main/java/org/implab/gradle/mercurial/tasks/HgTask.java +1 -1

             package org.implab.gradle.mercurial.tasks;
             import java.io.IOException;
             import java.util.ArrayList;
             import java.util.List;
             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;
+            import org.implab.gradle.mercurial.Utils;
             public class HgTask extends DefaultTask {
                 private final Property<String> cliCmd;
                 private List<Provider<String>> commandArgs;
                 private String commandOutput;
                 @Internal
                 protected MercurialExtension getMercurialExtension() {
                     return getProject().getExtensions().getByType(MercurialExtension.class);
                 }
                 public HgTask() {
                     cliCmd = getProject().getObjects().property(String.class);
                     cliCmd.convention(getMercurialExtension().getHgCmd());
                 }
                 @Internal
                 public String getCommandOutput() {
                     return commandOutput;
                 }
                 public void clearCommandArgs() {
                     commandArgs.clear();
                 }
                 public void commandArgs(Object... args) {
                     for (Object arg : args) {
                         if (arg == null)
                             continue;
                         if (arg instanceof Provider<?>)
                             commandArgs.add(((Provider<?>) arg).map(x -> x.toString()));
                         else
                             commandArgs.add(getProject().getProviders().provider(() -> arg.toString()));
                     }
                 }
                 @TaskAction
                 public void Run() throws IOException, InterruptedException, Exception {
                     List<String> commandLine = new ArrayList<>();
                     commandLine.add(cliCmd.get());
                     for (Provider<String> arg : commandArgs) {
                         if (arg.isPresent())
                             commandLine.add(arg.get());
                     }
                     getLogger().info("Starting: ", commandLine);
                     commandOutput = Utils.execCmd(commandLine, getMercurialExtension().getOutputCharset().name());
                 }
             }

readme.md +2 -2

             # Mercurial build integration
             ## SYNOPSIS
             ```groovy
             plugins {
-                id 'org.implab.gradle-mercurial' version '1.0.0' // or specify latest version
+                id 'org.implab.gradle-mercurial' version '1.0.1' // specify the latest version
             }
             mercurial {
                 releaseBookmark = 'prod'
                 preReleasePolicy { it
                     // this is the default behaviour
                     .addPatch(1)
                     .withPreRelease('snapshot')
-                    .withMeta('changeset')
+                    .withMeta(changeset)
                 }
                 // get version from repository and apply it to the project
                 applyVersioningPolicy()
             }
             ```
             ## DESCRIPTION
             ### `semver(versionString)`
             Parses the specified version string and returns the semantic version object
             ### `mercurial(Closure configure)`
             The extension added by the plugin to the project. Apply this plugin to the
             root project and use the `mercurial { ... }` section to configure the
             versioning.
             See the description below for more details about settings.
             #### `hgCmd`
             The command which will be executed to perform the mercurial commands.
             The default value is `hg`.
             #### `outputCharset`
             The charset for the `hgCmd` output, this property defaults
             to the default charset of the operating system.
             #### `hg(...args)`
             Executes the mercurial command, returns the command output as text.
             #### `workspaceInfo` (read-only)
             Returns the information about current workspace, see description
             below for details.
             #### `workspaceVersion`
             Returns the semantic version obtained from the repository. Querying
             this property will lead querying the workspace info.
             #### `applyVersioningPolicy()`
             Reads the workspace information and sets the version of the project
             according to settings.
             If the version was specified using properties, then the specified
             version will take preceding over the calculated one.
             #### `preReleasePolicy(Closure<SemVersion> config)`
             The closure which is used to calculate the version of the project
             when the current commit isn't marked with a version tag.
             The default behaviour is to increment the patch version and
             to set the pre-release suffix to `'snapshot'`.
             ### `WorkspaceInfo`
             This class encapsulates information about the current workspace.
             All properties are read-only.
             #### `versionTag`
             The original version tag from the repository before parsing.
             #### `changeSet`
             The changeset id of the current workspace.
             #### `versionDistance`
             The distance in commits to the versionTag
             #### `branch`
             The name of the current sources branch.
             #### `isDirty`
             This flag indicates uncommited changes to the workspace. This flag is useful
             to control some pipelines which run locally on developer machines.
             ## TASKS
             ### `release`
             Marks this commit with current version and pre-release suffix removed and
             moves the `release` bookmark to it.
             ### `staging`
             Marks this commit with current version and moves the `staging` bookmark to it.
             ### `printVersion`
             Prints the current version.

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