bool TryParseVersionAndPackage(LoopState loopState, out VersionRange snippetVersion, out string error)
        {
            snippetVersion = null;
            if (loopState.Version == null)
            {
                snippetVersion = fileVersion;
                error          = null;
                return(true);
            }

            VersionRange version;

            if (VersionRangeParser.TryParseVersion(loopState.Version, out version))
            {
                if (fileVersion.IsPreRelease())
                {
                    error = $"Could not use '{loopState.Version}' since directory is flagged as Prerelease. FileVersion: {fileVersion.ToFriendlyString()}.";
                    return(false);
                }
                snippetVersion = version;

                error = null;
                return(true);
            }

            error = $"Expected '{loopState.Version}' to be parsable as a version.";
            return(false);
        }
Exemple #2
0
        IEnumerable <Package> EnumeratePackages(string directory, string component, List <Snippet> globalShared, List <Snippet> componentShared)
        {
            var packageDirectories = Directory.EnumerateDirectories(directory, "*_*")
                                     .Where(s => !IsShared(s) &&
                                            fileFinder.IncludeDirectory(s));

            var packageVersionList = new List <PackageVersionCurrent>();

            foreach (var packageAndVersionDirectory in packageDirectories)
            {
                var name  = Path.GetFileName(packageAndVersionDirectory);
                var index = name.IndexOf('_');
                if (index < 1)
                {
                    throw new SnippetReadingException($"Expected the directory name '{name}' to be split by a '_'.");
                }

                var packageAlias = name.Substring(0, index);
                var package      = translatePackage(packageAlias);
                var versionPart  = name.Substring(index + 1, name.Length - index - 1);

                var pretext = PreTextReader.GetPretext(packageAndVersionDirectory);
                var version = VersionRangeParser.ParseVersion(versionPart, pretext);
                var item    = new PackageVersionCurrent
                {
                    Version      = version,
                    Package      = package,
                    PackageAlias = packageAlias,
                    Directory    = packageAndVersionDirectory,
                };
                packageVersionList.Add(item);
            }

            if (!packageVersionList.Any())
            {
                yield break;
            }

            packageVersionList = packageVersionList
                                 .OrderByDescending(x => x.Version)
                                 .ToList();
            packageVersionList = GetOrderedPackages(component, packageVersionList).ToList();

            SetCurrent(packageVersionList);
            foreach (var group in packageVersionList.GroupBy(
                         keySelector: _ => _.Package,
                         comparer: StringComparer.InvariantCultureIgnoreCase))
            {
                var          versions = new List <VersionGroup>();
                NuGetVersion previous = null;
                foreach (var packageAndVersion in group)
                {
                    VersionRange versionRange;
                    var          minVersion = packageAndVersion.Version;

                    if (previous == null)
                    {
                        versionRange = new VersionRange(
                            minVersion: minVersion,
                            includeMinVersion: true,
                            maxVersion: new NuGetVersion(minVersion.Major + 1, 0, 0),
                            includeMaxVersion: false
                            );
                    }
                    else
                    {
                        versionRange = new VersionRange(
                            minVersion: minVersion,
                            includeMinVersion: true,
                            maxVersion: new NuGetVersion(previous.Major, previous.Minor, previous.Patch),
                            includeMaxVersion: false
                            );
                    }

                    previous = minVersion;

                    var versionGroup = ReadVersion(
                        versionDirectory: packageAndVersion.Directory,
                        version: versionRange,
                        package: packageAndVersion.Package,
                        packageAlias: packageAndVersion.PackageAlias,
                        isCurrent: packageAndVersion.IsCurrent,
                        componentShared: componentShared,
                        globalShared: globalShared);
                    versions.Add(versionGroup);
                }

                yield return(new Package(group.Key, versions));
            }
        }