liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/metadata.liq

@@ -0,0 +1,253 @@
+let metadata.getter = ()
+
+# Create a getter from a metadata.
+# @category Metadata
+# @flag hidden
+# @param init Initial value.
+# @param map Function to apply to the metadata value to obtain the new value.
+# @param metadata Metadata on which the value should be updated.
+# @param s Source containing the metadata.
+def metadata.getter.base(init, map, metadata, s) =
+  x = ref(init)
+
+  def f(m) =
+    v = m[metadata]
+    if v != "" then x := map(v) end
+  end
+
+  s.on_metadata(synchronous=true, f)
+  ref.getter(x)
+end
+
+let metadata.getter.source = ()
+
+# Variant of `metadata.getter.base` which also returns the source. Using this
+# variant is a bit more complex, but safer this it does not involve a global
+# state, which might unexpectedly change the metadata if a source is used at
+# various places.
+# @flag hidden
+def metadata.getter.source.base(init, map, metadata, s) =
+  x = ref(init)
+
+  def f(m) =
+    v = m[metadata]
+    if v != "" then x := map(v) end
+  end
+
+  s.on_metadata(synchronous=true, f)
+  (s, ref.getter(x))
+end
+
+# Create a getter from a metadata: this is a string, whose value can be changed
+# with a metadata.
+# @category Metadata
+# @param init Initial value.
+# @param m Metadata on which the value should be updated.
+# @param s Source containing the metadata.
+def replaces metadata.getter(init, m, s) =
+  metadata.getter.base(init, fun (v) -> v, m, s)
+end
+
+# Create a float getter from a metadata: this is a float, whose value can be
+# changed with a metadata.
+# @category Metadata
+# @param init Initial value.
+# @param m Metadata on which the value should be updated.
+# @param s Source containing the metadata.
+def metadata.getter.float(init, m, s) =
+  metadata.getter.base(init, float_of_string, m, s)
+end
+
+# Create a float getter from a metadata: this is a float, whose value can be
+# changed with a metadata. This function also returns the source.
+# @category Metadata
+# @param init Initial value.
+# @param m Metadata on which the value should be updated.
+# @param s Source containing the metadata.
+def metadata.getter.source.float(init, m, s) =
+  metadata.getter.source.base(init, float_of_string, m, s)
+end
+
+# Extract filename from metadata.
+# @category Metadata
+def metadata.filename(m) =
+  m["filename"]
+end
+
+# Extract title from metadata.
+# @category Metadata
+def metadata.title(m) =
+  m["title"]
+end
+
+# Extract artist from metadata.
+# @category Metadata
+def metadata.artist(m) =
+  m["artist"]
+end
+
+# Extract comment from metadata.
+# @category Metadata
+def metadata.comment(m) =
+  m["comment"]
+end
+
+# Extract cover from metadata. This function implements cover extraction
+# for the following formats: coverart (ogg), apic (flac, mp3) and pic (mp3).
+# @category Metadata
+# @param m Metadata from which the cover should be extracted.
+# @param ~coverart_mime Mime type to use for `"coverart"` metadata. Support disabled if `null`.
+# @method mime MIME type for the cover.
+def metadata.cover(~coverart_mime=null, m) =
+  fname = metadata.filename(m)
+  if
+    list.assoc.mem("coverart", m) and null.defined(coverart_mime)
+  then
+    cover = list.assoc(default="", "coverart", m)
+    string.base64.decode(cover).{mime = null.get(coverart_mime)}
+  elsif
+    list.assoc.mem("metadata_block_picture", m)
+  then
+    # See https://xiph.org/flac/format.html#metadata_block_picture
+    cover = list.assoc(default="", "metadata_block_picture", m)
+    cover = file.metadata.flac.cover.decode(cover)
+    if
+      not null.defined(cover)
+    then
+      log.info(
+        "Failed to read cover metadata for #{fname}."
+      )
+      null
+    else
+      null.get(cover)
+    end
+  else
+    # Assume we have an mp3 file
+    m =
+      if
+        list.assoc.mem("apic", m) or list.assoc.mem("pic", m)
+      then
+        m
+      else
+        # Try the builtin tag reader because APIC tags are not read by default,
+        log.debug(
+          label="metadata.cover",
+          "APIC or PIC not found for #{fname}, trying builtin tag reader."
+        )
+
+        file.metadata.id3v2(fname)
+      end
+
+    pic = list.assoc(default="", "pic", m)
+    apic = list.assoc(default="", "apic", m)
+    if
+      apic != ""
+    then
+      log.debug(
+        label="metadata.cover",
+        "Found APIC for #{fname}."
+      )
+
+      # TODO: we could use file type in order to select cover if there are many
+      string.apic.parse(apic)
+    elsif
+      pic != ""
+    then
+      log.debug(
+        label="metadata.cover",
+        "Found APIC for #{fname}."
+      )
+
+      # TODO: we could use file type in order to select cover if there are many
+      pic = string.pic.parse(pic)
+      mime =
+        if
+          pic.format == "JPG"
+        then
+          "image/jpeg"
+        elsif
+          pic.format == "PNG"
+        then
+          "image/png"
+        else
+          "application/octet-stream"
+        end
+
+      pic.{mime = mime}
+    else
+      log.info(
+        "No cover found for #{fname}."
+      )
+      null
+    end
+  end
+end
+
+# Obtain cover-art for a file. `null` is returned in case there is no
+# such information.
+# @category Metadata
+# @param file File from which the cover should be obtained
+def file.cover(fname) =
+  metadata.cover(file.metadata(fname))
+end
+
+# Remove cover metadata.
+# @category Metadata
+def metadata.cover.remove(m) =
+  list.assoc.filter(
+    fun (k, (_:string)) -> not list.mem(k, settings.encoder.metadata.cover()),
+    m
+  )
+end
+
+# Cleanup metadata for export. This is used to remove Liquidsoap's internal
+# metadata entries before sending them. List of exported metadata is set using
+# `settings.encoder.metadata.export.set`.
+# @category Metadata
+def metadata.export(m) =
+  exported_keys = settings.encoder.metadata.export()
+  list.assoc.filter((fun (k, (_:string)) -> list.mem(k, exported_keys)), m)
+end
+
+let metadata.json = ()
+
+# Export metadata as JSON object. Cover art, if found, is extracted using
+# `metadata.cover` and exported with key `"cover"` and exported using
+# `string.data_uri.encode`.
+# @category Metadata
+# @param ~coverart_mime Mime type to use for `"coverart"` metadata. Support disasbled if `null`.
+# @param ~compact Output compact text.
+# @param ~json5 Use json5 extended spec.
+def metadata.json.stringify(
+  ~coverart_mime=null,
+  ~base64=true,
+  ~compact=false,
+  ~json5=false,
+  m
+) =
+  c = metadata.cover(coverart_mime=coverart_mime, m)
+  m = metadata.cover.remove(m)
+  m = metadata.export(m)
+  m =
+    if
+      null.defined(c)
+    then
+      c = null.get(c)
+      [("cover", string.data_uri.encode(base64=base64, mime=c.mime, c)), ...m]
+    else
+      m
+    end
+
+  data = json.object()
+  list.iter(fun (v) -> data.add(fst(v), snd(v)), m)
+  json.stringify(json5=json5, compact=compact, data)
+end
+
+# Parse metadata from JSON object.
+# @category Metadata
+def metadata.json.parse(json_string) =
+  let json.parse (metadata_list : [(string*string)] as json.object) =
+    json_string
+
+  metadata_list
+end

package/tests/liq/nfo.liq

@@ -0,0 +1,258 @@
+# Parse XML `.nfo` sidecar files (Kodi/Emby/Jellyfin style).
+#
+# This is meant to be used either directly via `file.nfo.metadata(...)` or as a
+# metadata resolver through `enable_nfo_metadata(...)`.
+
+# @category File
+# @flag hidden
+let file.nfo = ()
+
+# @flag hidden
+def file.nfo._normalize_tag(name) =
+  name = string.trim(name)
+
+  # Strip XML namespace prefix, if any (e.g. "x:title" -> "title").
+  # This also tolerates a leading ":" (malformed XML) by stripping it.
+  name = r/^[^:]*:/.replace(fun (_) -> "", name)
+  string.case(name)
+end
+
+# Accumulate values by key.
+# @flag hidden
+def file.nfo._accum_add(key, value, acc) =
+  # Values are stored in reverse order for cheap cons.
+  # Assoc-list update is O(n) in distinct keys (NFOs are typically small).
+  let (rev, found) =
+    list.fold(
+      fun (st, kv) ->
+        begin
+          let (rev, found) = st
+          if
+            fst(kv) == key
+          then
+            ([(key, value::snd(kv)), ...rev], true)
+          else
+            ([kv, ...rev], found)
+          end
+        end,
+      ([], false),
+      acc
+    )
+
+  if found then list.rev(rev) else list.rev([(key, [value]), ...rev]) end
+end
+
+# Build a tag rule table for `.nfo` parsing.
+#
+# Returned rule tables can be reused across multiple calls to `file.nfo.metadata`.
+#
+# @category File
+# @param ~extra_rules Additional tag rules (prepended to built-ins).
+def file.nfo.rules(~extra_rules=[]) =
+  extra_rules =
+    list.map(
+      fun (r) ->
+        begin
+          let (tag, rule_fn) = r
+          (file.nfo._normalize_tag(tag), rule_fn)
+        end,
+      extra_rules
+    )
+
+  def uniqueid_rule(node, txt) =
+    typ = list.assoc.nullable("type", node.xml_params)
+    typ = null.map(fun (t) -> string.case(string.trim(t)), typ)
+
+    is_default =
+      null.case(
+        list.assoc.nullable("default", node.xml_params),
+        {false},
+        fun (d) -> string.case(string.trim(d)) == "true"
+      )
+
+    def without_type() =
+      # Missing or invalid `type` (legacy / malformed input).
+      is_default
+        ? [("uniqueid.default", txt), ("uniqueid.untyped", txt)]
+        : [("uniqueid.untyped", txt)]
+    end
+
+    def with_type(t) =
+      # Standard case: typed ID.
+      kvs = [("uniqueid." ^ t, txt)]
+      if
+        is_default
+      then
+        [("uniqueid.default", txt), ("uniqueid.default.type", t), ...kvs]
+      else
+        kvs
+      end
+    end
+
+    null.case(
+      typ,
+      {without_type()},
+      fun (t) ->
+        # Some scrapers incorrectly emit `type="default"`. Kodi warns against it,
+        # so we treat it as untyped.
+        (t == "" or t == "default") ? without_type() : with_type(t)
+    )
+  end
+
+  [...extra_rules, ("uniqueid", uniqueid_rule)]
+end
+
+# Extract metadata from an `.nfo` file.
+#
+# Returned metadata keys are namespaced under `nfo.*`.
+#
+# Currently, only direct children of the root element that contain textual
+# content are extracted.
+#
+# Special case:
+# - `<uniqueid type="X">VALUE</uniqueid>` is exported as `nfo.uniqueid.X=VALUE`.
+# - If `default="true"`, the ID is also exported as `nfo.uniqueid.default=VALUE` and
+#   the type as `nfo.uniqueid.default.type=X`.
+#   If multiple IDs are marked default, values are joined with `;`.
+# - Typeless `<uniqueid>` (or `type="default"`, a scraper quirk) is exported as
+#   `nfo.uniqueid.untyped=VALUE`.
+# - Repeated tags are joined with `;` (in order of appearance).
+# - Tag names and unique ID types are lowercased; namespace prefixes are ignored.
+#
+# @category File
+# @param ~rules Tag rules. Use `file.nfo.rules(...)` to build them.
+# @param nfo_file Path to the `.nfo` file.
+def file.nfo.metadata(~rules=file.nfo.rules(), nfo_file) =
+  if
+    not (file.exists(nfo_file))
+  then
+    []
+  else
+    try
+      s = file.contents(nfo_file)
+      let xml.parse ((root_name, root) :
+        (
+          string
+          *
+          {
+            xml_params: [(string * string)],
+            xml_children: [
+              (
+                string
+                *
+                {
+                  xml_params: [(string * string)],
+                  xml_children: [(string * {xml_text: string})]
+                }
+              )
+            ]
+          }
+        )
+      ) = s
+
+      root_name = file.nfo._normalize_tag(root_name)
+
+      def collect(fields, child) =
+        let (name, node) = child
+        name = file.nfo._normalize_tag(name)
+        txts =
+          list.filter_map(
+            fun (child) ->
+              begin
+                let (name, node) = child
+                if
+                  name != "xml_text"
+                then
+                  null
+                else
+                  txt = string.trim(node.xml_text)
+                  txt == "" ? null : txt
+                end
+              end,
+            node.xml_children
+          )
+
+        txt = list.case(txts, null, fun (txt, _) -> txt)
+
+        null.case(
+          txt,
+          {fields},
+          fun (txt) ->
+            begin
+              rule = list.assoc.nullable(name, rules)
+
+              kvs =
+                null.case(
+                  rule,
+                  {[(name, txt)]},
+                  fun (rule_fn) -> rule_fn(node, txt)
+                )
+
+              def add(fields, kv) =
+                let (k, v) = kv
+                file.nfo._accum_add(k, v, fields)
+              end
+
+              list.fold(add, fields, kvs)
+            end
+        )
+      end
+
+      fields_by_key = list.fold(collect, [], root.xml_children)
+
+      fields_md =
+        list.map(
+          fun (kv) ->
+            begin
+              let (k, vs) = kv
+              ("nfo." ^ k, string.concat(separator=";", list.rev(vs)))
+            end,
+          fields_by_key
+        )
+
+      [("nfo.root", root_name), ...fields_md]
+    catch e do
+      log.important(
+        label="file.nfo.metadata",
+        "Failed to parse nfo file #{string.quote(nfo_file)}: #{e.kind}: #{
+          e.message
+        }"
+      )
+      []
+    end
+  end
+end
+
+# Enable `.nfo` sidecar metadata resolver.
+#
+# For a media file `.../Foo.ext`, this looks for a sibling `.../Foo.nfo`.
+#
+# @category Liquidsoap
+# @param ~priority Resolver priority. Default is low to avoid overriding media tags.
+# @param ~mime_types Restrict to these MIME types (or `null` for any).
+# @param ~file_extensions Restrict to these file extensions (or `null` for any).
+# @param ~extra_rules Additional tag rules (prepended to built-ins).
+# @param ~rules Pre-built tag rule table. When provided, `extra_rules` is ignored.
+def enable_nfo_metadata(
+  ~priority={0},
+  ~mime_types=null,
+  ~file_extensions=null,
+  ~extra_rules=[],
+  ~rules=null
+) =
+  rules =
+    null.case(rules, {file.nfo.rules(extra_rules=extra_rules)}, fun (r) -> r)
+
+  def resolver(~metadata:_, file_name) =
+    nfo_file = path.remove_extension(file_name) ^ ".nfo"
+    file.nfo.metadata(rules=rules, nfo_file)
+  end
+
+  decoder.metadata.add(
+    priority=priority,
+    mime_types=mime_types,
+    file_extensions=file_extensions,
+    "nfo",
+    resolver
+  )
+end

package/tests/liq/null.liq

@@ -0,0 +1,71 @@
+# Determine whether a nullable value is not null.
+# @category Programming
+def _null.defined(x) =
+  null.case(x, {false}, fun (_) -> true)
+end
+
+# Get the value of a nullable. Raises `error.not_found` if the value is `null`
+# and no default value was specified.
+# @category Programming
+# @param ~default Returned value when the value is `null`.
+def _null.get(~default=null, x) =
+  null.case(
+    x,
+    {
+      default
+        ?? error.raise(
+          error.not_found,
+          "no default value for null.get"
+        )
+    },
+    fun (x) -> x
+  )
+end
+
+# Convert a nullable value to a list containing zero or one element depending on
+# whether the value is null or not.
+# @category Programming
+def _null.to_list(x) =
+  null.case(x, {[]}, fun (x) -> [x])
+end
+
+# Apply a function on a nullable value if it is not null, and return null
+# otherwise.
+# @category Programming
+def _null.map(f, x) =
+  null.case(x, {null}, fun (x) -> f(x))
+end
+
+# Find the first element of a list for which the image of the function is not
+# `null`. Raises `error.not_found` if not element is found and no default value
+# was specified.
+# @category Programming
+# @param ~default Returned value when no element is found.
+# @param f Function.
+# @param l List.
+def _null.find(~default=null, f, l) =
+  def rec aux(l) =
+    f =
+      list.case(
+        l,
+        {
+          default
+            ?? error.raise(
+              error.not_found,
+              "no default value for list.find_defined"
+            )
+        },
+        fun (x, l) ->
+          {
+            begin
+              y = f(x)
+              if null.defined(y) then y else aux(l) end
+            end
+          }
+      )
+
+    f()
+  end
+
+  aux(l)
+end