path: root/mac/.config/mpv/scripts/fuzzydir.lua

--[[
	fuzzydir / by sibwaf / https://github.com/sibwaf/mpv-scripts

	Allows using "**" wildcards in sub-file-paths and audio-file-paths
    so you don't have to specify all the possible directory names.

    Basically, allows you to do this and never have the need to edit any paths ever again:
    audio-file-paths = **
    sub-file-paths = **

	MIT license - do whatever you want, but I'm not responsible for any possible problems.
	Please keep the URL to the original repository. Thanks!
]]

--[[
    Configuration:

    # max_search_depth

    Determines the max depth of recursive search, should be >= 1

    Examples for "sub-file-paths = **":
    "max_search_depth = 1" => mpv will be able to find [xyz.ass, subs/xyz.ass]
    "max_search_depth = 2" => mpv will be able to find [xyz.ass, subs/xyz.ass, subs/moresubs/xyz.ass]

    Please be careful when setting this value too high as it can result in awful performance or even stack overflow


    # discovery_threshold

    fuzzydir will skip paths which contain more than discovery_threshold directories in them

    This is done to keep at least some garbage from getting into *-file-paths properties in case of big collections:
    - dir1 <- will be ignored on opening video.mp4 as it's probably unrelated to the file
    - ...
    - dir999 <- will be ignored
    - video.mp4

    Use 0 to disable this behavior completely


    # use_powershell

    fuzzydir will use PowerShell to traverse directories when it's available

    Can be faster in some cases, but can also be significantly slower
]]

local max_search_depth = 3
local discovery_threshold = 10
local use_powershell = false

----------

local utils = require("mp.utils")
local msg = require("mp.msg")

local default_audio_paths = mp.get_property_native("options/audio-file-paths")
local default_sub_paths = mp.get_property_native("options/sub-file-paths")

function foreach(list, action)
	for _, item in pairs(list) do
		action(item)
	end
end

function starts_with(str, prefix)
	return string.sub(str, 1, string.len(prefix)) == prefix
end

function ends_with(str, suffix)
	return suffix == "" or string.sub(str, -string.len(suffix)) == suffix
end

function add_all(to, from)
	for index, element in pairs(from) do
		table.insert(to, element)
	end
end

function contains(t, e)
	for index, element in pairs(t) do
		if element == e then
			return true
		end
	end
	return false
end

function normalize(path)
	if path == "." then
		return ""
	end

	if starts_with(path, "./") or starts_with(path, ".\\") then
		path = string.sub(path, 3, -1)
	end
	if ends_with(path, "/") or ends_with(path, "\\") then
		path = string.sub(path, 1, -2)
	end

	return path
end

function call_command(command)
	local command_string = ""
	for _, part in pairs(command) do
		command_string = command_string .. part .. " "
	end

	msg.trace("Calling external command:", command_string)

	local process = mp.command_native({
		name = "subprocess",
		playback_only = false,
		capture_stdout = true,
		capture_stderr = true,
		args = command,
	})

	if process.status ~= 0 then
		msg.verbose("External command failed with status " .. process.status .. ": " .. command_string)
		if process.stderr ~= "" then
			msg.debug(process.stderr)
		end

		return nil
	end

	local result = {}
	for line in string.gmatch(process.stdout, "([^\r\n]+)") do
		table.insert(result, line)
	end
	return result
end

-- Platform-dependent optimization

local powershell_version = nil
if use_powershell then
	powershell_version = call_command({
		"powershell",
		"-NoProfile",
		"-Command",
		"$Host.Version.Major",
	})
end
if powershell_version ~= nil then
	powershell_version = tonumber(powershell_version[1])
end
if powershell_version == nil then
	powershell_version = -1
end
msg.debug("PowerShell version", powershell_version)

function fast_readdir(path)
	if powershell_version >= 3 then
		msg.trace("Scanning", path, "with PowerShell")
		result = call_command({
			"powershell",
			"-NoProfile",
			"-Command",
			[[
            $dirs = Get-ChildItem -LiteralPath ]] .. string.format("%q", path) .. [[ -Directory
            foreach($dir in $dirs) {
                $u8clip = [System.Text.Encoding]::UTF8.GetBytes($dir.Name)
                [Console]::OpenStandardOutput().Write($u8clip, 0, $u8clip.Length)
                Write-Host ""
            } ]],
		})
		msg.trace("Finished scanning", path, "with PowerShell")
		return result
	end

	msg.trace("Scanning", path, "with default readdir")
	result = utils.readdir(path, "dirs")
	msg.trace("Finished scanning", path, "with default readdir")
	return result
end

-- Platform-dependent optimization end

function traverse(search_path, current_path, level, cache)
	local full_path = utils.join_path(search_path, current_path)

	if level > max_search_depth then
		msg.trace("Traversed too deep, skipping scan for", full_path)
		return {}
	end

	if cache[full_path] ~= nil then
		msg.trace("Returning from cache for", full_path)
		return cache[full_path]
	end

	local result = {}

	local discovered_paths = fast_readdir(full_path)
	if discovered_paths == nil then
		-- noop
		msg.debug("Unable to scan " .. full_path .. ", skipping")
	elseif discovery_threshold > 0 and #discovered_paths > discovery_threshold then
		-- noop
		msg.debug("Too many directories in " .. full_path .. ", skipping")
	else
		for _, discovered_path in pairs(discovered_paths) do
			local new_path = utils.join_path(current_path, discovered_path)

			table.insert(result, new_path)
			add_all(result, traverse(search_path, new_path, level + 1, cache))
		end
	end

	cache[full_path] = result

	return result
end

function explode(raw_paths, search_path, cache)
	local result = {}
	for _, raw_path in pairs(raw_paths) do
		local parent, leftover = utils.split_path(raw_path)
		if leftover == "**" then
			msg.trace("Expanding wildcard for", raw_path)
			table.insert(result, parent)
			add_all(result, traverse(search_path, parent, 1, cache))
		else
			msg.trace("Path", raw_path, "doesn't have a wildcard, keeping as-is")
			table.insert(result, raw_path)
		end
	end

	local normalized = {}
	for index, path in pairs(result) do
		local normalized_path = normalize(path)
		if not contains(normalized, normalized_path) and normalized_path ~= "" then
			table.insert(normalized, normalized_path)
		end
	end

	return normalized
end

function explode_all()
	msg.debug("max_search_depth = " .. max_search_depth .. ", discovery_threshold = " .. discovery_threshold)

	local video_path = mp.get_property("path")
	local search_path, _ = utils.split_path(video_path)
	msg.debug("search_path = " .. search_path)

	local cache = {}

	foreach(default_audio_paths, function(it)
		msg.debug("audio-file-paths:", it)
	end)
	local audio_paths = explode(default_audio_paths, search_path, cache)
	foreach(audio_paths, function(it)
		msg.debug("Adding to audio-file-paths:", it)
	end)
	mp.set_property_native("options/audio-file-paths", audio_paths)

	msg.verbose("Done expanding audio-file-paths")

	foreach(default_sub_paths, function(it)
		msg.debug("sub-file-paths:", it)
	end)
	local sub_paths = explode(default_sub_paths, search_path, cache)
	foreach(sub_paths, function(it)
		msg.debug("Adding to sub-file-paths:", it)
	end)
	mp.set_property_native("options/sub-file-paths", sub_paths)

	msg.verbose("Done expanding sub-file-paths")

	msg.debug("Done expanding paths")
end

mp.add_hook("on_load", 50, explode_all)