hammerspoon/Spoons/SpoonInstall.spoon/docs.json

   1 [
   2   {
   3     "Constant" : [
   4
   5     ],
   6     "submodules" : [
   7
   8     ],
   9     "Function" : [
  10
  11     ],
  12     "Variable" : [
  13       {
  14         "doc" : "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon.",
  15         "stripped_doc" : [
  16           "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon."
  17         ],
  18         "def" : "SpoonInstall.logger",
  19         "parameters" : [
  20
  21         ],
  22         "notes" : [
  23
  24         ],
  25         "signature" : "SpoonInstall.logger",
  26         "type" : "Variable",
  27         "returns" : [
  28
  29         ],
  30         "name" : "logger",
  31         "desc" : "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon."
  32       },
  33       {
  34         "doc" : "Table containing the list of available Spoon repositories. The key\nof each entry is an identifier for the repository, and its value\nis a table with the following entries:\n * desc - Human-readable description for the repository\n * url - Base URL for the repository. For now the repository is assumed to be hosted in GitHub, and the URL should be the main base URL of the repository. Repository metadata needs to be stored under `docs\/docs.json`, and the Spoon zip files need to be stored under `Spoons\/`.\n\nDefault value:\n```\n{\n   default = {\n      url = \"https:\/\/github.com\/Hammerspoon\/Spoons\",\n      desc = \"Main Hammerspoon Spoon repository\",\n   }\n}\n```",
  35         "stripped_doc" : [
  36           "Table containing the list of available Spoon repositories. The key",
  37           "of each entry is an identifier for the repository, and its value",
  38           "is a table with the following entries:",
  39           " * desc - Human-readable description for the repository",
  40           " * url - Base URL for the repository. For now the repository is assumed to be hosted in GitHub, and the URL should be the main base URL of the repository. Repository metadata needs to be stored under `docs\/docs.json`, and the Spoon zip files need to be stored under `Spoons\/`.",
  41           "",
  42           "Default value:",
  43           "```",
  44           "{",
  45           "   default = {",
  46           "      url = \"https:\/\/github.com\/Hammerspoon\/Spoons\",",
  47           "      desc = \"Main Hammerspoon Spoon repository\",",
  48           "   }",
  49           "}",
  50           "```"
  51         ],
  52         "def" : "SpoonInstall.repos",
  53         "parameters" : [
  54
  55         ],
  56         "notes" : [
  57
  58         ],
  59         "signature" : "SpoonInstall.repos",
  60         "type" : "Variable",
  61         "returns" : [
  62
  63         ],
  64         "name" : "repos",
  65         "desc" : "Table containing the list of available Spoon repositories. The key"
  66       },
  67       {
  68         "doc" : "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`.\n\nKeep in mind that if you set this to `true`, Hammerspoon will\nblock until all missing Spoons are installed, but the notifications\nwill happen at a more \"human readable\" rate.",
  69         "stripped_doc" : [
  70           "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`.",
  71           "",
  72           "Keep in mind that if you set this to `true`, Hammerspoon will",
  73           "block until all missing Spoons are installed, but the notifications",
  74           "will happen at a more \"human readable\" rate."
  75         ],
  76         "def" : "SpoonInstall.use_syncinstall",
  77         "parameters" : [
  78
  79         ],
  80         "notes" : [
  81
  82         ],
  83         "signature" : "SpoonInstall.use_syncinstall",
  84         "type" : "Variable",
  85         "returns" : [
  86
  87         ],
  88         "name" : "use_syncinstall",
  89         "desc" : "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`."
  90       }
  91     ],
  92     "stripped_doc" : [
  93
  94     ],
  95     "desc" : "Install and manage Spoons and Spoon repositories",
  96     "Deprecated" : [
  97
  98     ],
  99     "type" : "Module",
 100     "Constructor" : [
 101
 102     ],
 103     "items" : [
 104       {
 105         "doc" : "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon.",
 106         "stripped_doc" : [
 107           "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon."
 108         ],
 109         "def" : "SpoonInstall.logger",
 110         "parameters" : [
 111
 112         ],
 113         "notes" : [
 114
 115         ],
 116         "signature" : "SpoonInstall.logger",
 117         "type" : "Variable",
 118         "returns" : [
 119
 120         ],
 121         "name" : "logger",
 122         "desc" : "Logger object used within the Spoon. Can be accessed to set the default log level for the messages coming from the Spoon."
 123       },
 124       {
 125         "doc" : "Table containing the list of available Spoon repositories. The key\nof each entry is an identifier for the repository, and its value\nis a table with the following entries:\n * desc - Human-readable description for the repository\n * url - Base URL for the repository. For now the repository is assumed to be hosted in GitHub, and the URL should be the main base URL of the repository. Repository metadata needs to be stored under `docs\/docs.json`, and the Spoon zip files need to be stored under `Spoons\/`.\n\nDefault value:\n```\n{\n   default = {\n      url = \"https:\/\/github.com\/Hammerspoon\/Spoons\",\n      desc = \"Main Hammerspoon Spoon repository\",\n   }\n}\n```",
 126         "stripped_doc" : [
 127           "Table containing the list of available Spoon repositories. The key",
 128           "of each entry is an identifier for the repository, and its value",
 129           "is a table with the following entries:",
 130           " * desc - Human-readable description for the repository",
 131           " * url - Base URL for the repository. For now the repository is assumed to be hosted in GitHub, and the URL should be the main base URL of the repository. Repository metadata needs to be stored under `docs\/docs.json`, and the Spoon zip files need to be stored under `Spoons\/`.",
 132           "",
 133           "Default value:",
 134           "```",
 135           "{",
 136           "   default = {",
 137           "      url = \"https:\/\/github.com\/Hammerspoon\/Spoons\",",
 138           "      desc = \"Main Hammerspoon Spoon repository\",",
 139           "   }",
 140           "}",
 141           "```"
 142         ],
 143         "def" : "SpoonInstall.repos",
 144         "parameters" : [
 145
 146         ],
 147         "notes" : [
 148
 149         ],
 150         "signature" : "SpoonInstall.repos",
 151         "type" : "Variable",
 152         "returns" : [
 153
 154         ],
 155         "name" : "repos",
 156         "desc" : "Table containing the list of available Spoon repositories. The key"
 157       },
 158       {
 159         "doc" : "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`.\n\nKeep in mind that if you set this to `true`, Hammerspoon will\nblock until all missing Spoons are installed, but the notifications\nwill happen at a more \"human readable\" rate.",
 160         "stripped_doc" : [
 161           "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`.",
 162           "",
 163           "Keep in mind that if you set this to `true`, Hammerspoon will",
 164           "block until all missing Spoons are installed, but the notifications",
 165           "will happen at a more \"human readable\" rate."
 166         ],
 167         "def" : "SpoonInstall.use_syncinstall",
 168         "parameters" : [
 169
 170         ],
 171         "notes" : [
 172
 173         ],
 174         "signature" : "SpoonInstall.use_syncinstall",
 175         "type" : "Variable",
 176         "returns" : [
 177
 178         ],
 179         "name" : "use_syncinstall",
 180         "desc" : "If `true`, `andUse()` will update repos and install packages synchronously. Defaults to `false`."
 181       },
 182       {
 183         "doc" : "Declaratively install, load and configure a Spoon\n\nParameters:\n * name - the name of the Spoon to install (without the `.spoon` extension). If the Spoon is already installed, it will be loaded using `hs.loadSpoon()`. If it is not installed, it will be installed using `SpoonInstall:asyncInstallSpoonFromRepo()` and then loaded.\n * arg - if provided, can be used to specify the configuration of the Spoon. The following keys are recognized (all are optional):\n   * repo - repository from where the Spoon should be installed if not present in the system, as defined in `SpoonInstall.repos`. Defaults to `\"default\"`.\n   * config - a table containing variables to be stored in the Spoon object to configure it. For example, `config = { answer = 42 }` will result in `spoon.<LoadedSpoon>.answer` being set to 42.\n   * hotkeys - a table containing hotkey bindings. If provided, will be passed as-is to the Spoon's `bindHotkeys()` method. The special string `\"default\"` can be given to use the Spoons `defaultHotkeys` variable, if it exists.\n   * fn - a function which will be called with the freshly-loaded Spoon object as its first argument.\n   * loglevel - if the Spoon has a variable called `logger`, its `setLogLevel()` method will be called with this value.\n   * start - if `true`, call the Spoon's `start()` method after configuring everything else.\n   * disable - if `true`, do nothing. Easier than commenting it out when you want to temporarily disable a spoon.\n\nReturns:\n * None",
 184         "stripped_doc" : [
 185           "Declaratively install, load and configure a Spoon",
 186           ""
 187         ],
 188         "def" : "SpoonInstall:andUse(name, arg)",
 189         "parameters" : [
 190           " * name - the name of the Spoon to install (without the `.spoon` extension). If the Spoon is already installed, it will be loaded using `hs.loadSpoon()`. If it is not installed, it will be installed using `SpoonInstall:asyncInstallSpoonFromRepo()` and then loaded.",
 191           " * arg - if provided, can be used to specify the configuration of the Spoon. The following keys are recognized (all are optional):",
 192           "   * repo - repository from where the Spoon should be installed if not present in the system, as defined in `SpoonInstall.repos`. Defaults to `\"default\"`.",
 193           "   * config - a table containing variables to be stored in the Spoon object to configure it. For example, `config = { answer = 42 }` will result in `spoon.<LoadedSpoon>.answer` being set to 42.",
 194           "   * hotkeys - a table containing hotkey bindings. If provided, will be passed as-is to the Spoon's `bindHotkeys()` method. The special string `\"default\"` can be given to use the Spoons `defaultHotkeys` variable, if it exists.",
 195           "   * fn - a function which will be called with the freshly-loaded Spoon object as its first argument.",
 196           "   * loglevel - if the Spoon has a variable called `logger`, its `setLogLevel()` method will be called with this value.",
 197           "   * start - if `true`, call the Spoon's `start()` method after configuring everything else.",
 198           "   * disable - if `true`, do nothing. Easier than commenting it out when you want to temporarily disable a spoon.",
 199           ""
 200         ],
 201         "notes" : [
 202
 203         ],
 204         "signature" : "SpoonInstall:andUse(name, arg)",
 205         "type" : "Method",
 206         "returns" : [
 207           " * None"
 208         ],
 209         "name" : "andUse",
 210         "desc" : "Declaratively install, load and configure a Spoon"
 211       },
 212       {
 213         "doc" : "Asynchronously install a Spoon from a registered repository\n\nParameters:\n * name - Name of the Spoon to install.\n * repo - Name of the repository to use. Defaults to `\"default\"`\n * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:\n   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file\n   * success - boolean indicating whether the installation was successful\n\nReturns:\n * `true` if the installation was correctly initiated (i.e. the repo and spoon name were correct), `false` otherwise.",
 214         "stripped_doc" : [
 215           "Asynchronously install a Spoon from a registered repository",
 216           ""
 217         ],
 218         "def" : "SpoonInstall:asyncInstallSpoonFromRepo(name, repo, callback)",
 219         "parameters" : [
 220           " * name - Name of the Spoon to install.",
 221           " * repo - Name of the repository to use. Defaults to `\"default\"`",
 222           " * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:",
 223           "   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file",
 224           "   * success - boolean indicating whether the installation was successful",
 225           ""
 226         ],
 227         "notes" : [
 228
 229         ],
 230         "signature" : "SpoonInstall:asyncInstallSpoonFromRepo(name, repo, callback)",
 231         "type" : "Method",
 232         "returns" : [
 233           " * `true` if the installation was correctly initiated (i.e. the repo and spoon name were correct), `false` otherwise."
 234         ],
 235         "name" : "asyncInstallSpoonFromRepo",
 236         "desc" : "Asynchronously install a Spoon from a registered repository"
 237       },
 238       {
 239         "doc" : "Asynchronously download a Spoon zip file and install it.\n\nParameters:\n * url - URL of the zip file to install.\n * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:\n   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file\n   * success - boolean indicating whether the installation was successful\n\nReturns:\n * `true` if the installation was correctly initiated (i.e. the URL is valid), `false` otherwise",
 240         "stripped_doc" : [
 241           "Asynchronously download a Spoon zip file and install it.",
 242           ""
 243         ],
 244         "def" : "SpoonInstall:asyncInstallSpoonFromZipURL(url, callback)",
 245         "parameters" : [
 246           " * url - URL of the zip file to install.",
 247           " * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:",
 248           "   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file",
 249           "   * success - boolean indicating whether the installation was successful",
 250           ""
 251         ],
 252         "notes" : [
 253
 254         ],
 255         "signature" : "SpoonInstall:asyncInstallSpoonFromZipURL(url, callback)",
 256         "type" : "Method",
 257         "returns" : [
 258           " * `true` if the installation was correctly initiated (i.e. the URL is valid), `false` otherwise"
 259         ],
 260         "name" : "asyncInstallSpoonFromZipURL",
 261         "desc" : "Asynchronously download a Spoon zip file and install it."
 262       },
 263       {
 264         "doc" : "Asynchronously fetch the information about the contents of a Spoon repository\n\nParameters:\n * repo - name of the repository to update. Defaults to `\"default\"`.\n * callback - if given, a function to be called after the update finishes (also if it fails). The function will receive the following arguments:\n   * repo - name of the repository\n   * success - boolean indicating whether the update succeeded\n\nReturns:\n * `true` if the update was correctly initiated (i.e. the repo name is valid), `nil` otherwise\n\nNotes:\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 265         "stripped_doc" : [
 266           "Asynchronously fetch the information about the contents of a Spoon repository",
 267           ""
 268         ],
 269         "def" : "SpoonInstall:asyncUpdateRepo(repo, callback)",
 270         "parameters" : [
 271           " * repo - name of the repository to update. Defaults to `\"default\"`.",
 272           " * callback - if given, a function to be called after the update finishes (also if it fails). The function will receive the following arguments:",
 273           "   * repo - name of the repository",
 274           "   * success - boolean indicating whether the update succeeded",
 275           ""
 276         ],
 277         "notes" : [
 278           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 279         ],
 280         "signature" : "SpoonInstall:asyncUpdateRepo(repo, callback)",
 281         "type" : "Method",
 282         "returns" : [
 283           " * `true` if the update was correctly initiated (i.e. the repo name is valid), `nil` otherwise",
 284           ""
 285         ],
 286         "name" : "asyncUpdateRepo",
 287         "desc" : "Asynchronously fetch the information about the contents of a Spoon repository"
 288       },
 289       {
 290         "doc" : "Synchronously install a Spoon from a registered repository\n\nParameters:\n * name = Name of the Spoon to install.\n * repo - Name of the repository to use. Defaults to `\"default\"`\n\nReturns:\n * `true` if the installation was successful, `nil` otherwise.",
 291         "stripped_doc" : [
 292           "Synchronously install a Spoon from a registered repository",
 293           ""
 294         ],
 295         "def" : "SpoonInstall:installSpoonFromRepo(name, repo)",
 296         "parameters" : [
 297           " * name = Name of the Spoon to install.",
 298           " * repo - Name of the repository to use. Defaults to `\"default\"`",
 299           ""
 300         ],
 301         "notes" : [
 302
 303         ],
 304         "signature" : "SpoonInstall:installSpoonFromRepo(name, repo)",
 305         "type" : "Method",
 306         "returns" : [
 307           " * `true` if the installation was successful, `nil` otherwise."
 308         ],
 309         "name" : "installSpoonFromRepo",
 310         "desc" : "Synchronously install a Spoon from a registered repository"
 311       },
 312       {
 313         "doc" : "Synchronously download a Spoon zip file and install it.\n\nParameters:\n * url - URL of the zip file to install.\n\nReturns:\n * `true` if the installation was successful, `nil` otherwise",
 314         "stripped_doc" : [
 315           "Synchronously download a Spoon zip file and install it.",
 316           ""
 317         ],
 318         "def" : "SpoonInstall:installSpoonFromZipURL(url)",
 319         "parameters" : [
 320           " * url - URL of the zip file to install.",
 321           ""
 322         ],
 323         "notes" : [
 324
 325         ],
 326         "signature" : "SpoonInstall:installSpoonFromZipURL(url)",
 327         "type" : "Method",
 328         "returns" : [
 329           " * `true` if the installation was successful, `nil` otherwise"
 330         ],
 331         "name" : "installSpoonFromZipURL",
 332         "desc" : "Synchronously download a Spoon zip file and install it."
 333       },
 334       {
 335         "doc" : "Return a sorted list of registered Spoon repositories\n\nParameters:\n * None\n\nReturns:\n * Table containing a list of strings with the repository identifiers",
 336         "stripped_doc" : [
 337           "Return a sorted list of registered Spoon repositories",
 338           ""
 339         ],
 340         "def" : "SpoonInstall:repolist()",
 341         "parameters" : [
 342           " * None",
 343           ""
 344         ],
 345         "notes" : [
 346
 347         ],
 348         "signature" : "SpoonInstall:repolist()",
 349         "type" : "Method",
 350         "returns" : [
 351           " * Table containing a list of strings with the repository identifiers"
 352         ],
 353         "name" : "repolist",
 354         "desc" : "Return a sorted list of registered Spoon repositories"
 355       },
 356       {
 357         "doc" : "Search repositories for a pattern\n\nParameters:\n * pat - Lua pattern that will be matched against the name and description of each spoon in the registered repositories. All text is converted to lowercase before searching it, so you can use all-lowercase in your pattern.\n\nReturns:\n * Table containing a list of matching entries. Each entry is a table with the following keys:\n   * name - Spoon name\n   * desc - description of the spoon\n   * repo - identifier in the repository where the match was found",
 358         "stripped_doc" : [
 359           "Search repositories for a pattern",
 360           ""
 361         ],
 362         "def" : "SpoonInstall:search(pat)",
 363         "parameters" : [
 364           " * pat - Lua pattern that will be matched against the name and description of each spoon in the registered repositories. All text is converted to lowercase before searching it, so you can use all-lowercase in your pattern.",
 365           ""
 366         ],
 367         "notes" : [
 368
 369         ],
 370         "signature" : "SpoonInstall:search(pat)",
 371         "type" : "Method",
 372         "returns" : [
 373           " * Table containing a list of matching entries. Each entry is a table with the following keys:",
 374           "   * name - Spoon name",
 375           "   * desc - description of the spoon",
 376           "   * repo - identifier in the repository where the match was found"
 377         ],
 378         "name" : "search",
 379         "desc" : "Search repositories for a pattern"
 380       },
 381       {
 382         "doc" : "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`\n\nParameters:\n * None\n\nReturns:\n * None\n\nNotes:\n * This is a synchronous call, which means Hammerspoon will be blocked until it finishes.\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 383         "stripped_doc" : [
 384           "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`",
 385           ""
 386         ],
 387         "def" : "SpoonInstall:updateAllRepos()",
 388         "parameters" : [
 389           " * None",
 390           ""
 391         ],
 392         "notes" : [
 393           " * This is a synchronous call, which means Hammerspoon will be blocked until it finishes.",
 394           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 395         ],
 396         "signature" : "SpoonInstall:updateAllRepos()",
 397         "type" : "Method",
 398         "returns" : [
 399           " * None",
 400           ""
 401         ],
 402         "name" : "updateAllRepos",
 403         "desc" : "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`"
 404       },
 405       {
 406         "doc" : "Synchronously fetch the information about the contents of a Spoon repository\n\nParameters:\n * repo - name of the repository to update. Defaults to `\"default\"`.\n\nReturns:\n * `true` if the update was successful, `nil` otherwise\n\nNotes:\n * This is a synchronous call, which means Hammerspoon will be blocked until it finishes. For use in your configuration files, it's advisable to use `SpoonInstall.asyncUpdateRepo()` instead.\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 407         "stripped_doc" : [
 408           "Synchronously fetch the information about the contents of a Spoon repository",
 409           ""
 410         ],
 411         "def" : "SpoonInstall:updateRepo(repo)",
 412         "parameters" : [
 413           " * repo - name of the repository to update. Defaults to `\"default\"`.",
 414           ""
 415         ],
 416         "notes" : [
 417           " * This is a synchronous call, which means Hammerspoon will be blocked until it finishes. For use in your configuration files, it's advisable to use `SpoonInstall.asyncUpdateRepo()` instead.",
 418           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 419         ],
 420         "signature" : "SpoonInstall:updateRepo(repo)",
 421         "type" : "Method",
 422         "returns" : [
 423           " * `true` if the update was successful, `nil` otherwise",
 424           ""
 425         ],
 426         "name" : "updateRepo",
 427         "desc" : "Synchronously fetch the information about the contents of a Spoon repository"
 428       }
 429     ],
 430     "doc" : "Install and manage Spoons and Spoon repositories\n\nDownload: [https:\/\/github.com\/Hammerspoon\/Spoons\/raw\/master\/Spoons\/SpoonInstall.spoon.zip](https:\/\/github.com\/Hammerspoon\/Spoons\/raw\/master\/Spoons\/SpoonInstall.spoon.zip)",
 431     "Command" : [
 432
 433     ],
 434     "Field" : [
 435
 436     ],
 437     "Method" : [
 438       {
 439         "doc" : "Asynchronously fetch the information about the contents of a Spoon repository\n\nParameters:\n * repo - name of the repository to update. Defaults to `\"default\"`.\n * callback - if given, a function to be called after the update finishes (also if it fails). The function will receive the following arguments:\n   * repo - name of the repository\n   * success - boolean indicating whether the update succeeded\n\nReturns:\n * `true` if the update was correctly initiated (i.e. the repo name is valid), `nil` otherwise\n\nNotes:\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 440         "stripped_doc" : [
 441           "Asynchronously fetch the information about the contents of a Spoon repository",
 442           ""
 443         ],
 444         "def" : "SpoonInstall:asyncUpdateRepo(repo, callback)",
 445         "parameters" : [
 446           " * repo - name of the repository to update. Defaults to `\"default\"`.",
 447           " * callback - if given, a function to be called after the update finishes (also if it fails). The function will receive the following arguments:",
 448           "   * repo - name of the repository",
 449           "   * success - boolean indicating whether the update succeeded",
 450           ""
 451         ],
 452         "notes" : [
 453           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 454         ],
 455         "signature" : "SpoonInstall:asyncUpdateRepo(repo, callback)",
 456         "type" : "Method",
 457         "returns" : [
 458           " * `true` if the update was correctly initiated (i.e. the repo name is valid), `nil` otherwise",
 459           ""
 460         ],
 461         "name" : "asyncUpdateRepo",
 462         "desc" : "Asynchronously fetch the information about the contents of a Spoon repository"
 463       },
 464       {
 465         "doc" : "Synchronously fetch the information about the contents of a Spoon repository\n\nParameters:\n * repo - name of the repository to update. Defaults to `\"default\"`.\n\nReturns:\n * `true` if the update was successful, `nil` otherwise\n\nNotes:\n * This is a synchronous call, which means Hammerspoon will be blocked until it finishes. For use in your configuration files, it's advisable to use `SpoonInstall.asyncUpdateRepo()` instead.\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 466         "stripped_doc" : [
 467           "Synchronously fetch the information about the contents of a Spoon repository",
 468           ""
 469         ],
 470         "def" : "SpoonInstall:updateRepo(repo)",
 471         "parameters" : [
 472           " * repo - name of the repository to update. Defaults to `\"default\"`.",
 473           ""
 474         ],
 475         "notes" : [
 476           " * This is a synchronous call, which means Hammerspoon will be blocked until it finishes. For use in your configuration files, it's advisable to use `SpoonInstall.asyncUpdateRepo()` instead.",
 477           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 478         ],
 479         "signature" : "SpoonInstall:updateRepo(repo)",
 480         "type" : "Method",
 481         "returns" : [
 482           " * `true` if the update was successful, `nil` otherwise",
 483           ""
 484         ],
 485         "name" : "updateRepo",
 486         "desc" : "Synchronously fetch the information about the contents of a Spoon repository"
 487       },
 488       {
 489         "doc" : "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`\n\nParameters:\n * None\n\nReturns:\n * None\n\nNotes:\n * This is a synchronous call, which means Hammerspoon will be blocked until it finishes.\n * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions.",
 490         "stripped_doc" : [
 491           "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`",
 492           ""
 493         ],
 494         "def" : "SpoonInstall:updateAllRepos()",
 495         "parameters" : [
 496           " * None",
 497           ""
 498         ],
 499         "notes" : [
 500           " * This is a synchronous call, which means Hammerspoon will be blocked until it finishes.",
 501           " * For now, the repository data is not persisted, so you need to update it after every restart if you want to use any of the install functions."
 502         ],
 503         "signature" : "SpoonInstall:updateAllRepos()",
 504         "type" : "Method",
 505         "returns" : [
 506           " * None",
 507           ""
 508         ],
 509         "name" : "updateAllRepos",
 510         "desc" : "Synchronously fetch the information about the contents of all Spoon repositories registered in `SpoonInstall.repos`"
 511       },
 512       {
 513         "doc" : "Return a sorted list of registered Spoon repositories\n\nParameters:\n * None\n\nReturns:\n * Table containing a list of strings with the repository identifiers",
 514         "stripped_doc" : [
 515           "Return a sorted list of registered Spoon repositories",
 516           ""
 517         ],
 518         "def" : "SpoonInstall:repolist()",
 519         "parameters" : [
 520           " * None",
 521           ""
 522         ],
 523         "notes" : [
 524
 525         ],
 526         "signature" : "SpoonInstall:repolist()",
 527         "type" : "Method",
 528         "returns" : [
 529           " * Table containing a list of strings with the repository identifiers"
 530         ],
 531         "name" : "repolist",
 532         "desc" : "Return a sorted list of registered Spoon repositories"
 533       },
 534       {
 535         "doc" : "Search repositories for a pattern\n\nParameters:\n * pat - Lua pattern that will be matched against the name and description of each spoon in the registered repositories. All text is converted to lowercase before searching it, so you can use all-lowercase in your pattern.\n\nReturns:\n * Table containing a list of matching entries. Each entry is a table with the following keys:\n   * name - Spoon name\n   * desc - description of the spoon\n   * repo - identifier in the repository where the match was found",
 536         "stripped_doc" : [
 537           "Search repositories for a pattern",
 538           ""
 539         ],
 540         "def" : "SpoonInstall:search(pat)",
 541         "parameters" : [
 542           " * pat - Lua pattern that will be matched against the name and description of each spoon in the registered repositories. All text is converted to lowercase before searching it, so you can use all-lowercase in your pattern.",
 543           ""
 544         ],
 545         "notes" : [
 546
 547         ],
 548         "signature" : "SpoonInstall:search(pat)",
 549         "type" : "Method",
 550         "returns" : [
 551           " * Table containing a list of matching entries. Each entry is a table with the following keys:",
 552           "   * name - Spoon name",
 553           "   * desc - description of the spoon",
 554           "   * repo - identifier in the repository where the match was found"
 555         ],
 556         "name" : "search",
 557         "desc" : "Search repositories for a pattern"
 558       },
 559       {
 560         "doc" : "Asynchronously download a Spoon zip file and install it.\n\nParameters:\n * url - URL of the zip file to install.\n * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:\n   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file\n   * success - boolean indicating whether the installation was successful\n\nReturns:\n * `true` if the installation was correctly initiated (i.e. the URL is valid), `false` otherwise",
 561         "stripped_doc" : [
 562           "Asynchronously download a Spoon zip file and install it.",
 563           ""
 564         ],
 565         "def" : "SpoonInstall:asyncInstallSpoonFromZipURL(url, callback)",
 566         "parameters" : [
 567           " * url - URL of the zip file to install.",
 568           " * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:",
 569           "   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file",
 570           "   * success - boolean indicating whether the installation was successful",
 571           ""
 572         ],
 573         "notes" : [
 574
 575         ],
 576         "signature" : "SpoonInstall:asyncInstallSpoonFromZipURL(url, callback)",
 577         "type" : "Method",
 578         "returns" : [
 579           " * `true` if the installation was correctly initiated (i.e. the URL is valid), `false` otherwise"
 580         ],
 581         "name" : "asyncInstallSpoonFromZipURL",
 582         "desc" : "Asynchronously download a Spoon zip file and install it."
 583       },
 584       {
 585         "doc" : "Synchronously download a Spoon zip file and install it.\n\nParameters:\n * url - URL of the zip file to install.\n\nReturns:\n * `true` if the installation was successful, `nil` otherwise",
 586         "stripped_doc" : [
 587           "Synchronously download a Spoon zip file and install it.",
 588           ""
 589         ],
 590         "def" : "SpoonInstall:installSpoonFromZipURL(url)",
 591         "parameters" : [
 592           " * url - URL of the zip file to install.",
 593           ""
 594         ],
 595         "notes" : [
 596
 597         ],
 598         "signature" : "SpoonInstall:installSpoonFromZipURL(url)",
 599         "type" : "Method",
 600         "returns" : [
 601           " * `true` if the installation was successful, `nil` otherwise"
 602         ],
 603         "name" : "installSpoonFromZipURL",
 604         "desc" : "Synchronously download a Spoon zip file and install it."
 605       },
 606       {
 607         "doc" : "Asynchronously install a Spoon from a registered repository\n\nParameters:\n * name - Name of the Spoon to install.\n * repo - Name of the repository to use. Defaults to `\"default\"`\n * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:\n   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file\n   * success - boolean indicating whether the installation was successful\n\nReturns:\n * `true` if the installation was correctly initiated (i.e. the repo and spoon name were correct), `false` otherwise.",
 608         "stripped_doc" : [
 609           "Asynchronously install a Spoon from a registered repository",
 610           ""
 611         ],
 612         "def" : "SpoonInstall:asyncInstallSpoonFromRepo(name, repo, callback)",
 613         "parameters" : [
 614           " * name - Name of the Spoon to install.",
 615           " * repo - Name of the repository to use. Defaults to `\"default\"`",
 616           " * callback - if given, a function to call after the installation finishes (also if it fails). The function receives the following arguments:",
 617           "   * urlparts - Result of calling `hs.http.urlParts` on the URL of the Spoon zip file",
 618           "   * success - boolean indicating whether the installation was successful",
 619           ""
 620         ],
 621         "notes" : [
 622
 623         ],
 624         "signature" : "SpoonInstall:asyncInstallSpoonFromRepo(name, repo, callback)",
 625         "type" : "Method",
 626         "returns" : [
 627           " * `true` if the installation was correctly initiated (i.e. the repo and spoon name were correct), `false` otherwise."
 628         ],
 629         "name" : "asyncInstallSpoonFromRepo",
 630         "desc" : "Asynchronously install a Spoon from a registered repository"
 631       },
 632       {
 633         "doc" : "Synchronously install a Spoon from a registered repository\n\nParameters:\n * name = Name of the Spoon to install.\n * repo - Name of the repository to use. Defaults to `\"default\"`\n\nReturns:\n * `true` if the installation was successful, `nil` otherwise.",
 634         "stripped_doc" : [
 635           "Synchronously install a Spoon from a registered repository",
 636           ""
 637         ],
 638         "def" : "SpoonInstall:installSpoonFromRepo(name, repo)",
 639         "parameters" : [
 640           " * name = Name of the Spoon to install.",
 641           " * repo - Name of the repository to use. Defaults to `\"default\"`",
 642           ""
 643         ],
 644         "notes" : [
 645
 646         ],
 647         "signature" : "SpoonInstall:installSpoonFromRepo(name, repo)",
 648         "type" : "Method",
 649         "returns" : [
 650           " * `true` if the installation was successful, `nil` otherwise."
 651         ],
 652         "name" : "installSpoonFromRepo",
 653         "desc" : "Synchronously install a Spoon from a registered repository"
 654       },
 655       {
 656         "doc" : "Declaratively install, load and configure a Spoon\n\nParameters:\n * name - the name of the Spoon to install (without the `.spoon` extension). If the Spoon is already installed, it will be loaded using `hs.loadSpoon()`. If it is not installed, it will be installed using `SpoonInstall:asyncInstallSpoonFromRepo()` and then loaded.\n * arg - if provided, can be used to specify the configuration of the Spoon. The following keys are recognized (all are optional):\n   * repo - repository from where the Spoon should be installed if not present in the system, as defined in `SpoonInstall.repos`. Defaults to `\"default\"`.\n   * config - a table containing variables to be stored in the Spoon object to configure it. For example, `config = { answer = 42 }` will result in `spoon.<LoadedSpoon>.answer` being set to 42.\n   * hotkeys - a table containing hotkey bindings. If provided, will be passed as-is to the Spoon's `bindHotkeys()` method. The special string `\"default\"` can be given to use the Spoons `defaultHotkeys` variable, if it exists.\n   * fn - a function which will be called with the freshly-loaded Spoon object as its first argument.\n   * loglevel - if the Spoon has a variable called `logger`, its `setLogLevel()` method will be called with this value.\n   * start - if `true`, call the Spoon's `start()` method after configuring everything else.\n   * disable - if `true`, do nothing. Easier than commenting it out when you want to temporarily disable a spoon.\n\nReturns:\n * None",
 657         "stripped_doc" : [
 658           "Declaratively install, load and configure a Spoon",
 659           ""
 660         ],
 661         "def" : "SpoonInstall:andUse(name, arg)",
 662         "parameters" : [
 663           " * name - the name of the Spoon to install (without the `.spoon` extension). If the Spoon is already installed, it will be loaded using `hs.loadSpoon()`. If it is not installed, it will be installed using `SpoonInstall:asyncInstallSpoonFromRepo()` and then loaded.",
 664           " * arg - if provided, can be used to specify the configuration of the Spoon. The following keys are recognized (all are optional):",
 665           "   * repo - repository from where the Spoon should be installed if not present in the system, as defined in `SpoonInstall.repos`. Defaults to `\"default\"`.",
 666           "   * config - a table containing variables to be stored in the Spoon object to configure it. For example, `config = { answer = 42 }` will result in `spoon.<LoadedSpoon>.answer` being set to 42.",
 667           "   * hotkeys - a table containing hotkey bindings. If provided, will be passed as-is to the Spoon's `bindHotkeys()` method. The special string `\"default\"` can be given to use the Spoons `defaultHotkeys` variable, if it exists.",
 668           "   * fn - a function which will be called with the freshly-loaded Spoon object as its first argument.",
 669           "   * loglevel - if the Spoon has a variable called `logger`, its `setLogLevel()` method will be called with this value.",
 670           "   * start - if `true`, call the Spoon's `start()` method after configuring everything else.",
 671           "   * disable - if `true`, do nothing. Easier than commenting it out when you want to temporarily disable a spoon.",
 672           ""
 673         ],
 674         "notes" : [
 675
 676         ],
 677         "signature" : "SpoonInstall:andUse(name, arg)",
 678         "type" : "Method",
 679         "returns" : [
 680           " * None"
 681         ],
 682         "name" : "andUse",
 683         "desc" : "Declaratively install, load and configure a Spoon"
 684       }
 685     ],
 686     "name" : "SpoonInstall"
 687   }
 688 ]