about summary refs log tree commit diff
path: root/lib/gvariant.nix
blob: 708213224d3e35fac34de148f12202c383890e73 (plain) (blame)
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
/*
  A partial and basic implementation of GVariant formatted strings.
  See [GVariant Format Strings](https://docs.gtk.org/glib/gvariant-format-strings.html) for details.

  :::{.warning}
  This API is not considered fully stable and it might therefore
  change in backwards incompatible ways without prior notice.
  :::
*/

# This file is based on https://github.com/nix-community/home-manager
# Copyright (c) 2017-2022 Home Manager contributors
{ lib }:

let
  inherit (lib)
    concatMapStringsSep concatStrings escape head replaceStrings;

  mkPrimitive = t: v: {
    _type = "gvariant";
    type = t;
    value = v;
    __toString = self: "@${self.type} ${toString self.value}"; # https://docs.gtk.org/glib/gvariant-text.html
  };

  type = {
    arrayOf = t: "a${t}";
    maybeOf = t: "m${t}";
    tupleOf = ts: "(${concatStrings ts})";
    dictionaryEntryOf = nameType: valueType: "{${nameType}${valueType}}";
    string = "s";
    boolean = "b";
    uchar = "y";
    int16 = "n";
    uint16 = "q";
    int32 = "i";
    uint32 = "u";
    int64 = "x";
    uint64 = "t";
    double = "d";
    variant = "v";
  };

  /* Check if a value is a GVariant value

     Type:
       isGVariant :: Any -> Bool
  */
  isGVariant = v: v._type or "" == "gvariant";

in
rec {

  inherit type isGVariant;

  /* Returns the GVariant value that most closely matches the given Nix value.
     If no GVariant value can be found unambiguously then error is thrown.

     Type:
       mkValue :: Any -> gvariant
  */
  mkValue = v:
    if builtins.isBool v then
      mkBoolean v
    else if builtins.isFloat v then
      mkDouble v
    else if builtins.isString v then
      mkString v
    else if builtins.isList v then
      mkArray v
    else if isGVariant v then
      v
    else
      throw "The GVariant type of ${v} can't be inferred.";

  /* Returns the GVariant array from the given type of the elements and a Nix list.

     Type:
       mkArray :: [Any] -> gvariant

     Example:
       # Creating a string array
       lib.gvariant.mkArray [ "a" "b" "c" ]
  */
  mkArray = elems:
    let
      vs = map mkValue (lib.throwIf (elems == [ ]) "Please create empty array with mkEmptyArray." elems);
      elemType = lib.throwIfNot (lib.all (t: (head vs).type == t) (map (v: v.type) vs))
        "Elements in a list should have same type."
        (head vs).type;
    in
    mkPrimitive (type.arrayOf elemType) vs // {
      __toString = self:
        "@${self.type} [${concatMapStringsSep "," toString self.value}]";
    };

  /* Returns the GVariant array from the given empty Nix list.

     Type:
       mkEmptyArray :: gvariant.type -> gvariant

     Example:
       # Creating an empty string array
       lib.gvariant.mkEmptyArray (lib.gvariant.type.string)
  */
  mkEmptyArray = elemType: mkPrimitive (type.arrayOf elemType) [ ] // {
    __toString = self: "@${self.type} []";
  };


  /* Returns the GVariant variant from the given Nix value. Variants are containers
     of different GVariant type.

     Type:
       mkVariant :: Any -> gvariant

     Example:
       lib.gvariant.mkArray [
         (lib.gvariant.mkVariant "a string")
         (lib.gvariant.mkVariant (lib.gvariant.mkInt32 1))
       ]
  */
  mkVariant = elem:
    let gvarElem = mkValue elem;
    in mkPrimitive type.variant gvarElem // {
      __toString = self: "<${toString self.value}>";
    };

  /* Returns the GVariant dictionary entry from the given key and value.

     Type:
       mkDictionaryEntry :: String -> Any -> gvariant

     Example:
       # A dictionary describing an Epiphany’s search provider
       [
         (lib.gvariant.mkDictionaryEntry "url" (lib.gvariant.mkVariant "https://duckduckgo.com/?q=%s&t=epiphany"))
         (lib.gvariant.mkDictionaryEntry "bang" (lib.gvariant.mkVariant "!d"))
         (lib.gvariant.mkDictionaryEntry "name" (lib.gvariant.mkVariant "DuckDuckGo"))
       ]
  */
  mkDictionaryEntry =
    # The key of the entry
    name:
    # The value of the entry
    value:
    let
      name' = mkValue name;
      value' = mkValue value;
      dictionaryType = type.dictionaryEntryOf name'.type value'.type;
    in
    mkPrimitive dictionaryType { inherit name value; } // {
      __toString = self: "@${self.type} {${name'},${value'}}";
    };

  /* Returns the GVariant maybe from the given element type.

     Type:
       mkMaybe :: gvariant.type -> Any -> gvariant
  */
  mkMaybe = elemType: elem:
    mkPrimitive (type.maybeOf elemType) elem // {
      __toString = self:
        if self.value == null then
          "@${self.type} nothing"
        else
          "just ${toString self.value}";
    };

  /* Returns the GVariant nothing from the given element type.

     Type:
       mkNothing :: gvariant.type -> gvariant
  */
  mkNothing = elemType: mkMaybe elemType null;

  /* Returns the GVariant just from the given Nix value.

     Type:
       mkJust :: Any -> gvariant
  */
  mkJust = elem: let gvarElem = mkValue elem; in mkMaybe gvarElem.type gvarElem;

  /* Returns the GVariant tuple from the given Nix list.

     Type:
       mkTuple :: [Any] -> gvariant
  */
  mkTuple = elems:
    let
      gvarElems = map mkValue elems;
      tupleType = type.tupleOf (map (e: e.type) gvarElems);
    in
    mkPrimitive tupleType gvarElems // {
      __toString = self:
        "@${self.type} (${concatMapStringsSep "," toString self.value})";
    };

  /* Returns the GVariant boolean from the given Nix bool value.

     Type:
       mkBoolean :: Bool -> gvariant
  */
  mkBoolean = v:
    mkPrimitive type.boolean v // {
      __toString = self: if self.value then "true" else "false";
    };

  /* Returns the GVariant string from the given Nix string value.

     Type:
       mkString :: String -> gvariant
  */
  mkString = v:
    let sanitize = s: replaceStrings [ "\n" ] [ "\\n" ] (escape [ "'" "\\" ] s);
    in mkPrimitive type.string v // {
      __toString = self: "'${sanitize self.value}'";
    };

  /* Returns the GVariant object path from the given Nix string value.

     Type:
       mkObjectpath :: String -> gvariant
  */
  mkObjectpath = v:
    mkPrimitive type.string v // {
      __toString = self: "objectpath '${escape [ "'" ] self.value}'";
    };

  /* Returns the GVariant uchar from the given Nix int value.

     Type:
       mkUchar :: Int -> gvariant
  */
  mkUchar = mkPrimitive type.uchar;

  /* Returns the GVariant int16 from the given Nix int value.

     Type:
       mkInt16 :: Int -> gvariant
  */
  mkInt16 = mkPrimitive type.int16;

  /* Returns the GVariant uint16 from the given Nix int value.

     Type:
       mkUint16 :: Int -> gvariant
  */
  mkUint16 = mkPrimitive type.uint16;

  /* Returns the GVariant int32 from the given Nix int value.

     Type:
       mkInt32 :: Int -> gvariant
  */
  mkInt32 = v:
    mkPrimitive type.int32 v // {
      __toString = self: toString self.value;
    };

  /* Returns the GVariant uint32 from the given Nix int value.

     Type:
       mkUint32 :: Int -> gvariant
  */
  mkUint32 = mkPrimitive type.uint32;

  /* Returns the GVariant int64 from the given Nix int value.

     Type:
       mkInt64 :: Int -> gvariant
  */
  mkInt64 = mkPrimitive type.int64;

  /* Returns the GVariant uint64 from the given Nix int value.

     Type:
       mkUint64 :: Int -> gvariant
  */
  mkUint64 = mkPrimitive type.uint64;

  /* Returns the GVariant double from the given Nix float value.

     Type:
       mkDouble :: Float -> gvariant
  */
  mkDouble = v:
    mkPrimitive type.double v // {
      __toString = self: toString self.value;
    };
}