< Summary - Jellyfin

Information
Class: Emby.Naming.Video.VideoListResolver
Assembly: Emby.Naming
File(s): /srv/git/jellyfin/Emby.Naming/Video/VideoListResolver.cs
Line coverage
100%
Covered lines: 82
Uncovered lines: 0
Coverable lines: 82
Total lines: 214
Line coverage: 100%
Branch coverage
100%
Covered branches: 50
Total branches: 50
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
Resolve(...)100%1212100%
GetVideosGroupedByVersion(...)100%2222100%
HaveSameYear(...)100%66100%
IsEligibleForMultiVersion(...)100%1010100%

File(s)

/srv/git/jellyfin/Emby.Naming/Video/VideoListResolver.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.IO;
 4using System.Linq;
 5using System.Text.RegularExpressions;
 6using Emby.Naming.Common;
 7using Jellyfin.Extensions;
 8using MediaBrowser.Model.IO;
 9
 10namespace Emby.Naming.Video
 11{
 12    /// <summary>
 13    /// Resolves alternative versions and extras from list of video files.
 14    /// </summary>
 15    public static partial class VideoListResolver
 16    {
 17        [GeneratedRegex("[0-9]{2}[0-9]+[ip]", RegexOptions.IgnoreCase)]
 18        private static partial Regex ResolutionRegex();
 19
 20        [GeneratedRegex(@"^\[([^]]*)\]")]
 21        private static partial Regex CheckMultiVersionRegex();
 22
 23        /// <summary>
 24        /// Resolves alternative versions and extras from list of video files.
 25        /// </summary>
 26        /// <param name="videoInfos">List of related video files.</param>
 27        /// <param name="namingOptions">The naming options.</param>
 28        /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
 29        /// <param name="parseName">Whether to parse the name or use the filename.</param>
 30        /// <param name="libraryRoot">Top-level folder for the containing library.</param>
 31        /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
 32        public static IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, NamingOptions namingOpti
 33        {
 34            // Filter out all extras, otherwise they could cause stacks to not be resolved
 35            // See the unit test TestStackedWithTrailer
 4036            var nonExtras = videoInfos
 4037                .Where(i => i.ExtraType is null)
 4038                .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory });
 39
 4040            var stackResult = StackResolver.Resolve(nonExtras, namingOptions).ToList();
 41
 4042            var remainingFiles = new List<VideoFileInfo>();
 4043            var standaloneMedia = new List<VideoFileInfo>();
 44
 40045            for (var i = 0; i < videoInfos.Count; i++)
 46            {
 16047                var current = videoInfos[i];
 16048                if (stackResult.Any(s => s.ContainsFile(current.Path, current.IsDirectory)))
 49                {
 50                    continue;
 51                }
 52
 14553                if (current.ExtraType is null)
 54                {
 12055                    standaloneMedia.Add(current);
 56                }
 57                else
 58                {
 2559                    remainingFiles.Add(current);
 60                }
 61            }
 62
 4063            var list = new List<VideoInfo>();
 64
 9265            foreach (var stack in stackResult)
 66            {
 667                var info = new VideoInfo(stack.Name)
 668                {
 669                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions, pars
 670                        .OfType<VideoFileInfo>()
 671                        .ToList()
 672                };
 73
 674                info.Year = info.Files[0].Year;
 675                list.Add(info);
 76            }
 77
 32078            foreach (var media in standaloneMedia)
 79            {
 12080                var info = new VideoInfo(media.Name) { Files = new[] { media } };
 81
 12082                info.Year = info.Files[0].Year;
 12083                list.Add(info);
 84            }
 85
 4086            if (supportMultiVersion)
 87            {
 4088                list = GetVideosGroupedByVersion(list, namingOptions);
 89            }
 90
 91            // Whatever files are left, just add them
 4092            list.AddRange(remainingFiles.Select(i => new VideoInfo(i.Name)
 4093            {
 4094                Files = new[] { i },
 4095                Year = i.Year,
 4096                ExtraType = i.ExtraType
 4097            }));
 98
 4099            return list;
 100        }
 101
 102        private static List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos, NamingOptions namingOptions)
 103        {
 40104            if (videos.Count == 0)
 105            {
 1106                return videos;
 107            }
 108
 39109            var folderName = Path.GetFileName(Path.GetDirectoryName(videos[0].Files[0].Path.AsSpan()));
 110
 39111            if (folderName.Length <= 1 || !HaveSameYear(videos))
 112            {
 17113                return videos;
 114            }
 115
 116            // Cannot use Span inside local functions and delegates thus we cannot use LINQ here nor merge with the abov
 22117            VideoInfo? primary = null;
 158118            for (var i = 0; i < videos.Count; i++)
 119            {
 67120                var video = videos[i];
 67121                if (video.ExtraType is not null)
 122                {
 123                    continue;
 124                }
 125
 67126                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension, namingOptions))
 127                {
 10128                    return videos;
 129                }
 130
 57131                if (folderName.Equals(video.Files[0].FileNameWithoutExtension, StringComparison.Ordinal))
 132                {
 7133                    primary = video;
 134                }
 135            }
 136
 12137            if (videos.Count > 1)
 138            {
 11139                var groups = videos.GroupBy(x => ResolutionRegex().IsMatch(x.Files[0].FileNameWithoutExtension)).ToList(
 11140                videos.Clear();
 54141                foreach (var group in groups)
 142                {
 16143                    if (group.Key)
 144                    {
 7145                        videos.InsertRange(0, group
 7146                            .OrderByDescending(x => ResolutionRegex().Match(x.Files[0].FileNameWithoutExtension.ToString
 7147                            .ThenBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
 148                    }
 149                    else
 150                    {
 9151                        videos.AddRange(group.OrderBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new Alphanume
 152                    }
 153                }
 154            }
 155
 12156            primary ??= videos[0];
 12157            videos.Remove(primary);
 158
 12159            var list = new List<VideoInfo>
 12160            {
 12161                primary
 12162            };
 163
 12164            list[0].AlternateVersions = videos.Select(x => x.Files[0]).ToArray();
 12165            list[0].Name = folderName.ToString();
 166
 12167            return list;
 168        }
 169
 170        private static bool HaveSameYear(IReadOnlyList<VideoInfo> videos)
 171        {
 26172            if (videos.Count == 1)
 173            {
 7174                return true;
 175            }
 176
 19177            var firstYear = videos[0].Year ?? -1;
 162178            for (var i = 1; i < videos.Count; i++)
 179            {
 66180                if ((videos[i].Year ?? -1) != firstYear)
 181                {
 4182                    return false;
 183                }
 184            }
 185
 15186            return true;
 187        }
 188
 189        private static bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename, Na
 190        {
 67191            if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase))
 192            {
 4193                return false;
 194            }
 195
 196            // Remove the folder name before cleaning as we don't care about cleaning that part
 63197            if (folderName.Length <= testFilename.Length)
 198            {
 63199                testFilename = testFilename[folderName.Length..].Trim();
 200            }
 201
 202            // There are no span overloads for regex unfortunately
 63203            if (CleanStringParser.TryClean(testFilename.ToString(), namingOptions.CleanStringRegexes, out var cleanName)
 204            {
 23205                testFilename = cleanName.AsSpan().Trim();
 206            }
 207
 208            // The CleanStringParser should have removed common keywords etc.
 63209            return testFilename.IsEmpty
 63210                   || testFilename[0] == '-'
 63211                   || CheckMultiVersionRegex().IsMatch(testFilename);
 212        }
 213    }
 214}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:20 AM
GitHub | reportgenerator.io

Methods/Properties

Resolve(System.Collections.Generic.IReadOnlyList`1<Emby.Naming.Video.VideoFileInfo>,Emby.Naming.Common.NamingOptions,System.Boolean,System.Boolean,System.String)
GetVideosGroupedByVersion(System.Collections.Generic.List`1<Emby.Naming.Video.VideoInfo>,Emby.Naming.Common.NamingOptions)
HaveSameYear(System.Collections.Generic.IReadOnlyList`1<Emby.Naming.Video.VideoInfo>)
IsEligibleForMultiVersion(System.ReadOnlySpan`1<System.Char>,System.ReadOnlySpan`1<System.Char>,Emby.Naming.Common.NamingOptions)