package shakuhachi

  1. Overview
  2. Docs
A music collection manager

Install 

dune-project
 Dependency

codeberg.org Readme Changelog Edit opam file Versions (5)

Authors

  1. E
    EruEri <nayinayu@mailo.com>

Maintainers

  1. E
    EruEri <nayinayu@mailo.com>

Sources

0.2.0.tar.gz
sha256=966fc8667c2aa9830e64950d2de74bd564a65d60e1f50cfd3dc1e99ef106dc47
sha512=6423ce04d784ba521a7f49fabdafbe036e2dd80cd08ca999fdc6767262d7f12aa4e5002d65efd4c568b343eaabf4d680191c88334d629e1ca0156084531e9e0b

doc/src/shakuhachi.query/queryAlbum.ml.html

Source file queryAlbum.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
(*****************************************************************************)
(*                                                                           *)
(*  Copyright (C) 2026 Yves Ndiaye                                           *)
(*                                                                           *)
(* This Source Code Form is subject to the terms of the Mozilla Public       *)
(* License, v. 2.0. If a copy of the MPL was not distributed with this       *)
(* file, You can obtain one at https://mozilla.org/MPL/2.0/.                 *)
(*                                                                           *)
(*****************************************************************************)

include QueryUtil

let matches_node subfields (album, stats, participants) node =
  let id = SkhcDb.Album.id album in
  let album_name = SkhcDb.Album.name album in
  let sort_name = SkhcDb.Album.sort_name album in
  let flag = SkhcDb.Album.flag album in
  let year = SkhcDb.Album.year album in
  let rating = SkhcDb.Album.rating album in
  let genre = SkhcDb.Album.genre album in
  let cover_path = SkhcDb.Album.cover_path album in
  let duration = SkhcDb.Album.Stats.duration stats in
  let music_count = SkhcDb.Album.Stats.music_count stats in
  let play_count = SkhcDb.Album.Stats.play_count stats in
  let size = SkhcDb.Album.Stats.size stats in
  let avg_duration = SkhcDb.Album.Stats.avg_duration stats in
  let avg_rating = SkhcDb.Album.Stats.avg_rating stats in
  let avg_size = SkhcDb.Album.Stats.avg_size stats in
  match node with
  | Node.Substring s ->
      let fields = match_participants participants in
      let fields =
        Substring.(
          SubFields.(
            fields |> add STitle album_name |> add SAlbum album_name
            |> add_field_if_some SGenre genre
            |> add_field_if_some SSortName sort_name
            |> filter (fun key _ -> List.mem key subfields)
            |> bindings |> List.map snd
          )
        )
      in
      List.exists (matches ~insensible:true false s) fields
  | Field (FString s) -> (
      let regex = Field.String.regex s in
      let insensible = Field.String.insensible s in
      let field = Field.String.field s in
      match field with
      | Title falbum | Album falbum ->
          matches ~insensible regex falbum album_name
      | SortName fsort_name ->
          omatches ~insensible regex fsort_name sort_name
      | Artist fartist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Artist roles
              && matches ~insensible regex fartist artist_name
            )
            participants
      | AlbumArtist falbum_artist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem AlbumArtist roles
              && matches ~insensible regex falbum_artist artist_name
            )
            participants
      | Composer fcomposer ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Composer roles
              && matches ~insensible regex fcomposer artist_name
            )
            participants
      | Genre fgenre ->
          omatches ~insensible regex fgenre genre
      | Path _ ->
          false
      | FileExtension _ ->
          false
    )
  | Field (FBool b) -> (
      match b with
      | Art b ->
          let cover = Option.is_some cover_path in
          b = cover
      | Flag b ->
          flag = b
    )
  | Field (FInt i) -> (
      match i with
      | Id fid ->
          Range.matches fid id
      | Size fsize ->
          Range.matches fsize size
      | Year fyear ->
          year
          |> Option.map (Range.matches fyear)
          |> Option.value ~default:false
      | Plays fcount ->
          Range.matches fcount play_count
      | Length flength ->
          Range.matches flength duration
      | Rating frating ->
          rating
          |> Option.map (Range.matches frating)
          |> Option.value ~default:false
      | AlbumCount fcount ->
          Range.matches fcount music_count
      | Track _ ->
          false
      | Disc _ ->
          false
    )
  | Field (FFloat f) -> (
      match f with
      | AvgDuration favg_duration ->
          Range.matches favg_duration avg_duration
      | AvgRating favg_rating ->
          Range.matches favg_rating avg_rating
      | AvgSize favg_size ->
          Range.matches favg_size avg_size
    )