public async Task NoCommitHasMinVersionAlpha1()
        {
            var repo = new MockRepoInspector(Array.Empty <MockRepoCommit>());

            var semver = await VersionCalculator.FromRepository(repo, new() { QueryRemoteTags = true });

            semver.Should().Be(new SemVer(0, 1, 0, "alpha.1"));
        }
Ejemplo n.º 2
0
        private async Task <bool> ExecuteAsync()
        {
            var log = new MsBuildLogger(Log)
            {
                Verbosity = DecodeVerbosity(Verbosity, nameof(Verbosity)),
            };
            var commandRunner = new MsBuildCommandRunner(
                new SystemCommandRunner(),
                Log);

            var opts = new VersionCalculationOptions();
            {
                FilterTags = FilterTags.Trim();

                bool disableTagPrefix = bool.TryParse(DisableTagPrefix, out bool parsedBool) && parsedBool;
                if (disableTagPrefix)
                {
                    if (!string.IsNullOrWhiteSpace(TagPrefix))
                    {
                        throw new MsBuildException("TagPrefix cannot be set with DisablePrefix.");
                    }
                    opts.TagPrefix = "";
                }
                else if (!string.IsNullOrWhiteSpace(TagPrefix))
                {
                    opts.TagPrefix = TagPrefix;
                }

                if (!string.IsNullOrWhiteSpace(DefaultPrereleasePhase))
                {
                    opts.DefaultPrereleasePhase = DefaultPrereleasePhase;
                }

                if (!string.IsNullOrWhiteSpace(MinimumVersion))
                {
                    opts.MinimumVersion = DecodeVersion(
                        MinimumVersion, nameof(MinimumVersion));
                }

                if (!string.IsNullOrWhiteSpace(PrereleaseBaseHeight))
                {
                    opts.PrereleaseBaseHeight = DecodeInt(
                        PrereleaseBaseHeight, nameof(PrereleaseBaseHeight));
                }

                if (!string.IsNullOrWhiteSpace(VersionOverride))
                {
                    opts.VersionOverride = DecodeVersion(
                        VersionOverride, nameof(VersionOverride));
                }

                if (!string.IsNullOrWhiteSpace(BuildMetadata))
                {
                    opts.BuildMetadata = BuildMetadata;
                }

                if (!string.IsNullOrWhiteSpace(AutoIncrement))
                {
                    opts.AutoIncrement = DecodeVersionPart(
                        AutoIncrement, nameof(AutoIncrement));
                }
            }

            var version = opts.VersionOverride ?? new SemVer();

            if (opts.VersionOverride is null)
            {
                var repo = await GitRepoInspector.FromPath(ProjectDirectory, log, commandRunner);


                ITagFilter?tagFilter = null;
                if (!string.IsNullOrWhiteSpace(FilterTags))
                {
                    tagFilter = new CommandTagFilter(commandRunner, log, FilterTags, ProjectDirectory);
                }

                version = await VersionCalculator.FromRepository(repo, opts, log, tagFilter);
            }

            Version              = version.ToString();
            VersionMajor         = version.Major.ToString(CultureInfo.InvariantCulture);
            VersionMinor         = version.Minor.ToString(CultureInfo.InvariantCulture);
            VersionPatch         = version.Patch.ToString(CultureInfo.InvariantCulture);
            VersionPrerelease    = version.Prerelease ?? string.Empty;
            VersionBuildMetadata = version.BuildMetadata ?? string.Empty;
            return(true);
        }