| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Globalization; |
| | | 4 | | using System.Linq; |
| | | 5 | | using Emby.Naming.Common; |
| | | 6 | | |
| | | 7 | | namespace Emby.Naming.TV |
| | | 8 | | { |
| | | 9 | | /// <summary> |
| | | 10 | | /// Used to parse information about episode from path. |
| | | 11 | | /// </summary> |
| | | 12 | | public class EpisodePathParser |
| | | 13 | | { |
| | | 14 | | private readonly NamingOptions _options; |
| | | 15 | | |
| | | 16 | | /// <summary> |
| | | 17 | | /// Initializes a new instance of the <see cref="EpisodePathParser"/> class. |
| | | 18 | | /// </summary> |
| | | 19 | | /// <param name="options"><see cref="NamingOptions"/> object containing EpisodeExpressions and MultipleEpisodeEx |
| | | 20 | | public EpisodePathParser(NamingOptions options) |
| | | 21 | | { |
| | 347 | 22 | | _options = options; |
| | 347 | 23 | | } |
| | | 24 | | |
| | | 25 | | /// <summary> |
| | | 26 | | /// Parses information about episode from path. |
| | | 27 | | /// </summary> |
| | | 28 | | /// <param name="path">Path.</param> |
| | | 29 | | /// <param name="isDirectory">Is path for a directory or file.</param> |
| | | 30 | | /// <param name="isNamed">Do we want to use IsNamed expressions.</param> |
| | | 31 | | /// <param name="isOptimistic">Do we want to use Optimistic expressions.</param> |
| | | 32 | | /// <param name="supportsAbsoluteNumbers">Do we want to use expressions supporting absolute episode numbers.</pa |
| | | 33 | | /// <param name="fillExtendedInfo">Should we attempt to retrieve extended information.</param> |
| | | 34 | | /// <returns>Returns <see cref="EpisodePathParserResult"/> object.</returns> |
| | | 35 | | public EpisodePathParserResult Parse( |
| | | 36 | | string path, |
| | | 37 | | bool isDirectory, |
| | | 38 | | bool? isNamed = null, |
| | | 39 | | bool? isOptimistic = null, |
| | | 40 | | bool? supportsAbsoluteNumbers = null, |
| | | 41 | | bool fillExtendedInfo = true) |
| | | 42 | | { |
| | | 43 | | // Added to be able to use regex patterns which require a file extension. |
| | | 44 | | // There were no failed tests without this block, but to be safe, we can keep it until |
| | | 45 | | // the regex which require file extensions are modified so that they don't need them. |
| | 318 | 46 | | if (isDirectory) |
| | | 47 | | { |
| | 8 | 48 | | path += ".mp4"; |
| | | 49 | | } |
| | | 50 | | |
| | 318 | 51 | | EpisodePathParserResult? result = null; |
| | | 52 | | |
| | 4803 | 53 | | foreach (var expression in _options.EpisodeExpressions) |
| | | 54 | | { |
| | 2240 | 55 | | if (supportsAbsoluteNumbers.HasValue |
| | 2240 | 56 | | && expression.SupportsAbsoluteEpisodeNumbers != supportsAbsoluteNumbers.Value) |
| | | 57 | | { |
| | | 58 | | continue; |
| | | 59 | | } |
| | | 60 | | |
| | 2239 | 61 | | if (isNamed.HasValue && expression.IsNamed != isNamed.Value) |
| | | 62 | | { |
| | | 63 | | continue; |
| | | 64 | | } |
| | | 65 | | |
| | 2233 | 66 | | if (isOptimistic.HasValue && expression.IsOptimistic != isOptimistic.Value) |
| | | 67 | | { |
| | | 68 | | continue; |
| | | 69 | | } |
| | | 70 | | |
| | 2205 | 71 | | var currentResult = Parse(path, expression); |
| | 2205 | 72 | | if (currentResult.Success) |
| | | 73 | | { |
| | 313 | 74 | | result = currentResult; |
| | 313 | 75 | | break; |
| | | 76 | | } |
| | | 77 | | } |
| | | 78 | | |
| | 318 | 79 | | if (result is not null && fillExtendedInfo) |
| | | 80 | | { |
| | 242 | 81 | | FillAdditional(path, result); |
| | | 82 | | |
| | 242 | 83 | | if (!string.IsNullOrEmpty(result.SeriesName)) |
| | | 84 | | { |
| | 142 | 85 | | result.SeriesName = result.SeriesName |
| | 142 | 86 | | .Trim() |
| | 142 | 87 | | .Trim('_', '.', '-') |
| | 142 | 88 | | .Trim(); |
| | | 89 | | } |
| | | 90 | | } |
| | | 91 | | |
| | 318 | 92 | | return result ?? new EpisodePathParserResult(); |
| | | 93 | | } |
| | | 94 | | |
| | | 95 | | private static EpisodePathParserResult Parse(string name, EpisodeExpression expression) |
| | | 96 | | { |
| | 7298 | 97 | | var result = new EpisodePathParserResult(); |
| | | 98 | | |
| | | 99 | | // This is a hack to handle wmc naming |
| | 7298 | 100 | | if (expression.IsByDate) |
| | | 101 | | { |
| | 360 | 102 | | name = name.Replace('_', '-'); |
| | | 103 | | } |
| | | 104 | | |
| | 7298 | 105 | | var match = expression.Regex.Match(name); |
| | | 106 | | |
| | | 107 | | // (Full)(Season)(Episode)(Extension) |
| | 7298 | 108 | | if (match.Success && match.Groups.Count >= 3) |
| | | 109 | | { |
| | 808 | 110 | | if (expression.IsByDate) |
| | | 111 | | { |
| | | 112 | | DateTime date; |
| | 6 | 113 | | if (expression.DateTimeFormats.Length > 0) |
| | | 114 | | { |
| | 5 | 115 | | if (DateTime.TryParseExact( |
| | 5 | 116 | | match.Groups[0].ValueSpan, |
| | 5 | 117 | | expression.DateTimeFormats, |
| | 5 | 118 | | CultureInfo.InvariantCulture, |
| | 5 | 119 | | DateTimeStyles.None, |
| | 5 | 120 | | out date)) |
| | | 121 | | { |
| | 5 | 122 | | result.Year = date.Year; |
| | 5 | 123 | | result.Month = date.Month; |
| | 5 | 124 | | result.Day = date.Day; |
| | 5 | 125 | | result.Success = true; |
| | | 126 | | } |
| | | 127 | | } |
| | 1 | 128 | | else if (DateTime.TryParse(match.Groups[0].ValueSpan, CultureInfo.InvariantCulture, out date)) |
| | | 129 | | { |
| | 1 | 130 | | result.Year = date.Year; |
| | 1 | 131 | | result.Month = date.Month; |
| | 1 | 132 | | result.Day = date.Day; |
| | 1 | 133 | | result.Success = true; |
| | | 134 | | } |
| | | 135 | | |
| | | 136 | | // TODO: Only consider success if date successfully parsed? |
| | 6 | 137 | | result.Success = true; |
| | | 138 | | } |
| | 802 | 139 | | else if (expression.IsNamed) |
| | | 140 | | { |
| | 708 | 141 | | if (int.TryParse(match.Groups["seasonnumber"].ValueSpan, NumberStyles.Integer, CultureInfo.Invariant |
| | | 142 | | { |
| | 574 | 143 | | result.SeasonNumber = num; |
| | | 144 | | } |
| | | 145 | | |
| | 708 | 146 | | if (int.TryParse(match.Groups["epnumber"].ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCult |
| | | 147 | | { |
| | 675 | 148 | | result.EpisodeNumber = num; |
| | | 149 | | } |
| | | 150 | | |
| | 708 | 151 | | var endingNumberGroup = match.Groups["endingepnumber"]; |
| | 708 | 152 | | if (endingNumberGroup.Success) |
| | | 153 | | { |
| | | 154 | | // Will only set EndingEpisodeNumber if the captured number is not followed by additional number |
| | | 155 | | // or a 'p' or 'i' as what you would get with a pixel resolution specification. |
| | | 156 | | // It avoids erroneous parsing of something like "series-s09e14-1080p.mkv" as a multi-episode fr |
| | 132 | 157 | | int nextIndex = endingNumberGroup.Index + endingNumberGroup.Length; |
| | 132 | 158 | | if (nextIndex >= name.Length |
| | 132 | 159 | | || !"0123456789iIpP".Contains(name[nextIndex], StringComparison.Ordinal)) |
| | | 160 | | { |
| | | 161 | | // A range cannot end before it starts, so a lower number belongs to the episode title rathe |
| | 129 | 162 | | if (int.TryParse(endingNumberGroup.ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCul |
| | 129 | 163 | | && num >= result.EpisodeNumber) |
| | | 164 | | { |
| | 127 | 165 | | result.EndingEpisodeNumber = num; |
| | | 166 | | } |
| | | 167 | | } |
| | | 168 | | } |
| | | 169 | | |
| | 708 | 170 | | result.SeriesName = match.Groups["seriesname"].Value; |
| | 708 | 171 | | result.Success = result.EpisodeNumber.HasValue; |
| | | 172 | | } |
| | | 173 | | else |
| | | 174 | | { |
| | 94 | 175 | | if (int.TryParse(match.Groups[1].ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCulture, out |
| | | 176 | | { |
| | 92 | 177 | | result.SeasonNumber = num; |
| | | 178 | | } |
| | | 179 | | |
| | 94 | 180 | | if (int.TryParse(match.Groups[2].ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCulture, out |
| | | 181 | | { |
| | 94 | 182 | | result.EpisodeNumber = num; |
| | | 183 | | } |
| | | 184 | | |
| | 94 | 185 | | result.Success = result.EpisodeNumber.HasValue; |
| | | 186 | | } |
| | | 187 | | |
| | | 188 | | // Invalidate match when the season is 200 through 1927 or above 2500 |
| | | 189 | | // because it is an error unless the TV show is intentionally using false season numbers. |
| | | 190 | | // It avoids erroneous parsing of something like "Series Special (1920x1080).mkv" as being season 1920 e |
| | 808 | 191 | | if ((result.SeasonNumber >= 200 && result.SeasonNumber < 1928) |
| | 808 | 192 | | || result.SeasonNumber > 2500) |
| | | 193 | | { |
| | 2 | 194 | | result.Success = false; |
| | | 195 | | } |
| | | 196 | | |
| | 808 | 197 | | result.IsByDate = expression.IsByDate; |
| | | 198 | | } |
| | | 199 | | |
| | 7298 | 200 | | return result; |
| | | 201 | | } |
| | | 202 | | |
| | | 203 | | private void FillAdditional(string path, EpisodePathParserResult info) |
| | | 204 | | { |
| | 242 | 205 | | var expressions = _options.MultipleEpisodeExpressions.Where(i => i.IsNamed).ToList(); |
| | | 206 | | |
| | 242 | 207 | | if (string.IsNullOrEmpty(info.SeriesName)) |
| | | 208 | | { |
| | 154 | 209 | | expressions.InsertRange(0, _options.EpisodeExpressions.Where(i => i.IsNamed)); |
| | | 210 | | } |
| | | 211 | | |
| | 242 | 212 | | FillAdditional(path, info, expressions); |
| | 242 | 213 | | } |
| | | 214 | | |
| | | 215 | | private void FillAdditional(string path, EpisodePathParserResult info, IEnumerable<EpisodeExpression> expression |
| | | 216 | | { |
| | 10623 | 217 | | foreach (var i in expressions) |
| | | 218 | | { |
| | 5093 | 219 | | var result = Parse(path, i); |
| | | 220 | | |
| | 5093 | 221 | | if (!result.Success) |
| | | 222 | | { |
| | | 223 | | continue; |
| | | 224 | | } |
| | | 225 | | |
| | 460 | 226 | | if (string.IsNullOrEmpty(info.SeriesName)) |
| | | 227 | | { |
| | 378 | 228 | | info.SeriesName = result.SeriesName; |
| | | 229 | | } |
| | | 230 | | |
| | 460 | 231 | | if (!info.EndingEpisodeNumber.HasValue && result.EndingEpisodeNumber >= info.EpisodeNumber) |
| | | 232 | | { |
| | 79 | 233 | | info.EndingEpisodeNumber = result.EndingEpisodeNumber; |
| | | 234 | | } |
| | | 235 | | |
| | 460 | 236 | | if (!string.IsNullOrEmpty(info.SeriesName) |
| | 460 | 237 | | && (!info.EpisodeNumber.HasValue || info.EndingEpisodeNumber.HasValue)) |
| | | 238 | | { |
| | 42 | 239 | | break; |
| | | 240 | | } |
| | | 241 | | } |
| | 242 | 242 | | } |
| | | 243 | | } |
| | | 244 | | } |