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.3.0_1.tar.gz
sha256=541a7ac078a520730a71edf4d2fe0f17cc98f0b9ad82060db62120a7d2519ae5
sha512=37b98cb52dab8293adb92f71e91394cf1c5d0d481d03893c320cc8aa550459a30dabdfdc0018f512d3a7a547f2899b493a20d86f450bc084b78e30b40234a911

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
123
124
125
126
127
128
129
130
131
132
133
134
(*****************************************************************************)
(*                                                                           *)
(*  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 =
        Substrings.(
          fields |> add Title album_name |> add Album album_name
          |> add_field_if_some Genre genre
          |> add_field_if_some SortName 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.key s in
      let value = Field.String.value s in
      match field with
      | Title | Album ->
          matches ~insensible regex value album_name
      | SortName ->
          omatches ~insensible regex value sort_name
      | Artist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Artist roles
              && matches ~insensible regex value artist_name
            )
            participants
      | AlbumArtist ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem AlbumArtist roles
              && matches ~insensible regex value artist_name
            )
            participants
      | Composer ->
          SkhcDb.Ids.Map.exists
            (fun _ (artist_name, roles) ->
              SkhcDb.Roles.mem Composer roles
              && matches ~insensible regex value artist_name
            )
            participants
      | Genre ->
          omatches ~insensible regex value genre
      | Path ->
          false
      | Arbitrary _ ->
          false
      | FileExtension ->
          false
    )
  | Field (FBool b) -> (
      let field = Field.Bool.key b in
      let b = Field.Bool.value b in
      match field with
      | Art ->
          let cover = Option.is_some cover_path in
          b = cover
      | Flag ->
          flag = b
    )
  | Field (FInt64 i64) -> (
      let field = Field.Int64.key i64 in
      let frange = Field.Int64.value i64 in
      match field with
      | Id ->
          Range.matches frange id
      | Size ->
          Range.matches frange size
    )
  | Field (FInt i) -> (
      let field = Field.Int.key i in
      let frange = Field.Int.value i in
      match field with
      | Year ->
          year
          |> Option.map (Range.matches frange)
          |> Option.value ~default:false
      | Plays ->
          Range.matches frange play_count
      | Length ->
          Range.matches frange duration
      | Rating ->
          rating
          |> Option.map (Range.matches frange)
          |> Option.value ~default:false
      | AlbumCount ->
          Range.matches frange music_count
      | Track ->
          false
      | Disc ->
          false
    )
  | Field (FFloat f) -> (
      let field = Field.Float.key f in
      let frange = Field.Float.value f in
      match field with
      | AvgDuration ->
          Range.matches frange avg_duration
      | AvgRating ->
          Range.matches frange avg_rating
      | AvgSize ->
          Range.matches frange avg_size
    )