public void ScriptNamingScheme_With_IncludeBaseFolderName_And_Prefix_Set_ShoudUsePrefixBeforeFolderName() { var scripts = new List <ScriptBatch>() { new ScriptBatch(ScriptProviderHelper.GetFolder(GetBasePath(), "Naming"), false, true, 0, Constants.Default.Encoding) }; var namingOptions = new NamingOptions(false, includeBaseFolderName: true, "prefix_"); var upgradeEngineBuilder = DeployChanges.To .SqlDatabase("testconn") .OverrideConnectionFactory(testConnectionFactory) .LogTo(Logger).Some <UpgradeEngineBuilder, Error>() .SelectScripts(scripts, namingOptions); upgradeEngineBuilder.MatchSome(x => { x.Build().PerformUpgrade(); }); var executedScripts = Logger.GetExecutedScripts(); executedScripts[0].Should().Be("prefix_Naming.SubFolder.001.sql"); }
private static bool IsEligibleForMultiVersion(ReadOnlySpan <char> folderName, string testFilePath, NamingOptions namingOptions) { var testFilename = Path.GetFileNameWithoutExtension(testFilePath.AsSpan()); if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase)) { return(false); } // Remove the folder name before cleaning as we don't care about cleaning that part if (folderName.Length <= testFilename.Length) { testFilename = testFilename[folderName.Length..].Trim();
/// <summary> /// Initializes a new instance of the <see cref="AudioBookListResolver"/> class. /// </summary> /// <param name="options">Naming options passed along to <see cref="AudioBookResolver"/> and <see cref="AudioBookNameParser"/>.</param> public AudioBookListResolver(NamingOptions options) { _options = options; }
public CleanDateTimeParser(NamingOptions options, IRegexProvider iRegexProvider) { _options = options; _iRegexProvider = iRegexProvider; }
public EpisodeResolver(NamingOptions options, ILogger logger) : this(options, logger, new RegexProvider()) { }
private VideoListResolver GetResolver() { var options = new NamingOptions(); return(new VideoListResolver(options)); }
public VideoResolver(NamingOptions options) { _options = options; }
public EpisodePathParser(NamingOptions options) { _options = options; }
/// <summary> /// Tries to get name and year from raw name. /// </summary> /// <param name="name">Raw name.</param> /// <param name="namingOptions">The naming options.</param> /// <returns>Returns <see cref="CleanDateTimeResult"/> with name and optional year.</returns> public static CleanDateTimeResult CleanDateTime(string name, NamingOptions namingOptions) { return(CleanDateTimeParser.Clean(name, namingOptions.CleanDateTimeRegexes)); }
/// <summary> /// Tries to clean name of clutter. /// </summary> /// <param name="name">Raw name.</param> /// <param name="namingOptions">The naming options.</param> /// <param name="newName">Clean name.</param> /// <returns>True if cleaning of name was successful.</returns> public static bool TryCleanString([NotNullWhen(true)] string?name, NamingOptions namingOptions, out string newName) { return(CleanStringParser.TryClean(name, namingOptions.CleanStringRegexes, out newName)); }
/// <summary> /// Determines if path is video file stub based on extension. /// </summary> /// <param name="path">Path to file.</param> /// <param name="namingOptions">The naming options.</param> /// <returns>True if is video file stub.</returns> public static bool IsStubFile(string path, NamingOptions namingOptions) { var extension = Path.GetExtension(path.AsSpan()); return(namingOptions.StubFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase)); }
public AudioBookFilePathParser(NamingOptions options) { _options = options; }
public EpisodeResolver(NamingOptions options) : this(options, new RegexProvider()) { }
public GenericVideoResolver(NamingOptions namingOptions) : base(namingOptions) { }
public static string GetNiceTypeName(System.Type type) { var options = new NamingOptions(); options.NameOverrideFunc = GetCSharpTypeAlias; return GetNiceTypeName(type, options); }
public static string GetNiceTypeName(System.Type type, NamingOptions options) { if (options != null && options.NameOverrideFunc !=null) { string s = options.NameOverrideFunc(type); if (s != null) { return s; } } if (IsNullableType(type)) { var actualtype = type.GetGenericArguments()[0]; return GetNiceTypeName(actualtype, options) + "?"; } if (type.IsArray) { var at = type.GetElementType(); return string.Format("{0}[]", GetNiceTypeName(at, options)); } if (type.IsGenericType) { var sb = new System.Text.StringBuilder(); var tokens = type.Name.Split('`'); sb.Append(tokens[0]); var gas = type.GetGenericArguments(); var ga_names = gas.Select(i => GetNiceTypeName(i, options)); sb.Append("<"); Join(sb, ", ", ga_names); sb.Append(">"); return sb.ToString(); } return type.Name; }
public EpisodeResolver(NamingOptions options) { _options = options; }
/// <summary> /// Resolves the directory. /// </summary> /// <param name="path">The path.</param> /// <param name="namingOptions">The naming options.</param> /// <param name="parseName">Whether to parse the name or use the filename.</param> /// <returns>VideoFileInfo.</returns> public static VideoFileInfo?ResolveDirectory(string?path, NamingOptions namingOptions, bool parseName = true) { return(Resolve(path, true, namingOptions, parseName)); }
public VideoResolver(NamingOptions options, ILogger logger, IRegexProvider regexProvider) { _options = options; _logger = logger; _regexProvider = regexProvider; }
/// <summary> /// Resolves the file. /// </summary> /// <param name="path">The path.</param> /// <param name="namingOptions">The naming options.</param> /// <returns>VideoFileInfo.</returns> public static VideoFileInfo?ResolveFile(string?path, NamingOptions namingOptions) { return(Resolve(path, false, namingOptions)); }
private AudioBookListResolver GetResolver() { var options = new NamingOptions(); return(new AudioBookListResolver(options)); }
/// <summary> /// Resolves the specified path. /// </summary> /// <param name="path">The path.</param> /// <param name="isDirectory">if set to <c>true</c> [is folder].</param> /// <param name="namingOptions">The naming options.</param> /// <param name="parseName">Whether or not the name should be parsed for info.</param> /// <returns>VideoFileInfo.</returns> /// <exception cref="ArgumentNullException"><c>path</c> is <c>null</c>.</exception> public static VideoFileInfo?Resolve(string?path, bool isDirectory, NamingOptions namingOptions, bool parseName = true) { if (string.IsNullOrEmpty(path)) { return(null); } bool isStub = false; ReadOnlySpan <char> container = ReadOnlySpan <char> .Empty; string?stubType = null; if (!isDirectory) { var extension = Path.GetExtension(path.AsSpan()); // Check supported extensions if (!namingOptions.VideoFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase)) { // It's not supported. Check stub extensions if (!StubResolver.TryResolveFile(path, namingOptions, out stubType)) { return(null); } isStub = true; } container = extension.TrimStart('.'); } var format3DResult = Format3DParser.Parse(path, namingOptions); var extraResult = ExtraResolver.GetExtraInfo(path, namingOptions); var name = Path.GetFileNameWithoutExtension(path); int?year = null; if (parseName) { var cleanDateTimeResult = CleanDateTime(name, namingOptions); name = cleanDateTimeResult.Name; year = cleanDateTimeResult.Year; if (extraResult.ExtraType == null && TryCleanString(name, namingOptions, out var newName)) { name = newName; } } return(new VideoFileInfo( path: path, container: container.IsEmpty ? null : container.ToString(), isStub: isStub, name: name, year: year, stubType: stubType, is3D: format3DResult.Is3D, format3D: format3DResult.Format3D, extraType: extraResult.ExtraType, isDirectory: isDirectory, extraRule: extraResult.Rule)); }
public CleanDateTimeParser(NamingOptions options) { _options = options; }
public ProductContext(DbContextOptions options, EnumLookupOptions enumLookupOptions, NamingOptions namingOptions) : base(options) { EnumLookupOptions = enumLookupOptions; NamingOptions = namingOptions; }
public EpisodeResolver(NamingOptions options, ILogger logger, IRegexProvider iRegexProvider) { _options = options; _logger = logger; _iRegexProvider = iRegexProvider; }
public StubResolver(NamingOptions options) { _options = options; }
public AudioFileParser(NamingOptions options) { _options = options; }
public EpisodePathParser(NamingOptions options, IRegexProvider iRegexProvider) { _options = options; _iRegexProvider = iRegexProvider; }
private static List <VideoInfo> GetVideosGroupedByVersion(List <VideoInfo> videos, NamingOptions namingOptions) { if (videos.Count == 0) { return(videos); } var folderName = Path.GetFileName(Path.GetDirectoryName(videos[0].Files[0].Path.AsSpan())); if (folderName.Length <= 1 || !HaveSameYear(videos)) { return(videos); } // Cannot use Span inside local functions and delegates thus we cannot use LINQ here nor merge with the above [if] for (var i = 0; i < videos.Count; i++) { var video = videos[i]; if (!IsEligibleForMultiVersion(folderName, video.Files[0].Path, namingOptions)) { return(videos); } } // The list is created and overwritten in the caller, so we are allowed to do in-place sorting videos.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.Ordinal)); var list = new List <VideoInfo> { videos[0] }; var alternateVersionsLen = videos.Count - 1; var alternateVersions = new VideoFileInfo[alternateVersionsLen]; var extras = new List <VideoFileInfo>(list[0].Extras); for (int i = 0; i < alternateVersionsLen; i++) { var video = videos[i + 1]; alternateVersions[i] = video.Files[0]; extras.AddRange(video.Extras); } list[0].AlternateVersions = alternateVersions; list[0].Name = folderName.ToString(); list[0].Extras = extras; return(list); }
public VideoListResolver(NamingOptions options) : this(options, new RegexProvider()) { }
/// <summary> /// Resolves alternative versions and extras from list of video files. /// </summary> /// <param name="files">List of related video files.</param> /// <param name="namingOptions">The naming options.</param> /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param> /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns> public static IEnumerable <VideoInfo> Resolve(IEnumerable <FileSystemMetadata> files, NamingOptions namingOptions, bool supportMultiVersion = true) { var videoInfos = files .Select(i => VideoResolver.Resolve(i.FullName, i.IsDirectory, namingOptions)) .OfType <VideoFileInfo>() .ToList(); // Filter out all extras, otherwise they could cause stacks to not be resolved // See the unit test TestStackedWithTrailer var nonExtras = videoInfos .Where(i => i.ExtraType == null) .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory }); var stackResult = new StackResolver(namingOptions) .Resolve(nonExtras).ToList(); var remainingFiles = videoInfos .Where(i => !stackResult.Any(s => i.Path != null && s.ContainsFile(i.Path, i.IsDirectory))) .ToList(); var list = new List <VideoInfo>(); foreach (var stack in stackResult) { var info = new VideoInfo(stack.Name) { Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions)) .OfType <VideoFileInfo>() .ToList() }; info.Year = info.Files[0].Year; var extras = ExtractExtras(remainingFiles, stack.Name, Path.GetFileNameWithoutExtension(stack.Files[0].AsSpan()), namingOptions.VideoFlagDelimiters); if (extras.Count > 0) { info.Extras = extras; } list.Add(info); } var standaloneMedia = remainingFiles .Where(i => i.ExtraType == null) .ToList(); foreach (var media in standaloneMedia) { var info = new VideoInfo(media.Name) { Files = new[] { media } }; info.Year = info.Files[0].Year; remainingFiles.Remove(media); var extras = ExtractExtras(remainingFiles, media.FileNameWithoutExtension, namingOptions.VideoFlagDelimiters); info.Extras = extras; list.Add(info); } if (supportMultiVersion) { list = GetVideosGroupedByVersion(list, namingOptions); } // If there's only one resolved video, use the folder name as well to find extras if (list.Count == 1) { var info = list[0]; var videoPath = list[0].Files[0].Path; var parentPath = Path.GetDirectoryName(videoPath.AsSpan()); if (!parentPath.IsEmpty) { var folderName = Path.GetFileName(parentPath); if (!folderName.IsEmpty) { var extras = ExtractExtras(remainingFiles, folderName, namingOptions.VideoFlagDelimiters); extras.AddRange(info.Extras); info.Extras = extras; } } // Add the extras that are just based on file name as well var extrasByFileName = remainingFiles .Where(i => i.ExtraRule != null && i.ExtraRule.RuleType == ExtraRuleType.Filename) .ToList(); remainingFiles = remainingFiles .Except(extrasByFileName) .ToList(); extrasByFileName.AddRange(info.Extras); info.Extras = extrasByFileName; } // If there's only one video, accept all trailers // Be lenient because people use all kinds of mishmash conventions with trailers. if (list.Count == 1) { var trailers = remainingFiles .Where(i => i.ExtraType == ExtraType.Trailer) .ToList(); trailers.AddRange(list[0].Extras); list[0].Extras = trailers; remainingFiles = remainingFiles .Except(trailers) .ToList(); } // Whatever files are left, just add them list.AddRange(remainingFiles.Select(i => new VideoInfo(i.Name) { Files = new[] { i }, Year = i.Year })); return(list); }
public VideoListResolver(NamingOptions options, IRegexProvider regexProvider) { _options = options; _regexProvider = regexProvider; }