src/nitpm.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Nit package manager command line interface
  16 module nitpm
  17
  18 import opts
  19 import prompt
  20 import ini
  21 import curl
  22
  23 import nitpm_shared
  24
  25 # Command line action, passed after `nitpm`
  26 abstract class Command
  27
  28         # Short name of the command, specified in the command line
  29         fun name: String is abstract
  30
  31         # Short usage description
  32         fun usage: String is abstract
  33
  34         # Command description
  35         fun description: String is abstract
  36
  37         # Apply this command consiering the `args` that follow
  38         fun apply(args: Array[String]) do end
  39
  40         private var all_commands: Map[String, Command]
  41
  42         init do all_commands[name] = self
  43
  44         # Print the help message for this command
  45         fun print_local_help
  46         do
  47                 print "usage: {usage}"
  48                 print ""
  49                 print "  {description}"
  50         end
  51 end
  52
  53 # Install a new package
  54 class CommandInstall
  55         super Command
  56
  57         redef fun name do return "install"
  58         redef fun usage do return "nitpm install [package0[=version] [package1 ...]]"
  59         redef fun description do return "Install packages by name, Git repository address or from the local package.ini"
  60
  61         # Packages installed in this run (identified by the full path)
  62         private var installed = new Array[String]
  63
  64         redef fun apply(args)
  65         do
  66                 if args.not_empty then
  67                         # Install each package
  68                         for arg in args do
  69                                 # Parse each arg as an import string, with versions and commas
  70                                 install_packages arg
  71                         end
  72                 else
  73                         # Install packages from local package.ini
  74                         var ini_path = "package.ini"
  75                         if not ini_path.file_exists then
  76                                 print_error "Local `package.ini` not found."
  77                                 print_local_help
  78                                 exit 1
  79                         end
  80
  81                         var ini = new ConfigTree(ini_path)
  82                         var import_line = ini["package.import"]
  83                         if import_line == null then
  84                                 print_error "The local `package.ini` declares no external dependencies."
  85                                 exit 0
  86                                 abort
  87                         end
  88
  89                         install_packages import_line
  90                 end
  91         end
  92
  93         # Install packages defined by the `import_line`
  94         private fun install_packages(import_line: String)
  95         do
  96                 var imports = import_line.parse_import
  97                 for name, ext_package in imports do
  98                         install_package(ext_package.id, ext_package.version)
  99                 end
 100         end
 101
 102         # Install the `package_id` at `version`
 103         private fun install_package(package_id: String, version: nullable String)
 104         do
 105                 if package_id.is_package_name then
 106                         # Ask a centralized server
 107                         # TODO choose a future safe URL
 108                         # TODO customizable server list
 109                         # TODO parse ini file in memory
 110
 111                         var url = "https://xymus.net/nitpm/{package_id}.ini"
 112                         var ini_path = "/tmp/{package_id}.ini"
 113
 114                         if verbose then print "Looking for a package description at '{url}'"
 115
 116                         var request = new CurlHTTPRequest(url)
 117                         request.verbose = verbose
 118                         var response = request.download_to_file(ini_path)
 119
 120                         if response isa CurlResponseFailed then
 121                                 print_error "Failed to contact the remote server at '{url}': {response.error_msg} ({response.error_code})"
 122                                 exit 1
 123                         end
 124
 125                         assert response isa CurlFileResponseSuccess
 126                         if response.status_code == 404 then
 127                                 print_error "Package '{package_id}' not found on the server"
 128                                 exit 1
 129                         else if response.status_code != 200 then
 130                                 print_error "Server side error: {response.status_code}"
 131                                 exit 1
 132                         end
 133
 134                         if verbose then
 135                                 print "Found a package description:"
 136                                 print ini_path.to_path.read_all
 137                         end
 138
 139                         var ini = new ConfigTree(ini_path)
 140                         var git_repo = ini["upstream.git"]
 141                         if git_repo == null then
 142                                 print_error "Package description invalid, or it does not declare a Git repository"
 143                                 exit 1
 144                                 abort
 145                         end
 146
 147                         install_from_git(git_repo, package_id, version)
 148                 else
 149                         var name = package_id.git_name
 150                         if name != null and name != "." and not name.is_empty then
 151                                 name = name.to_lower
 152                                 install_from_git(package_id, name, version)
 153                         else
 154                                 print_error "Failed to infer the package name"
 155                                 exit 1
 156                         end
 157                 end
 158         end
 159
 160         private fun install_from_git(git_repo, name: String, version: nullable String)
 161         do
 162                 check_git
 163
 164                 var target_dir = nitpm_lib_dir / name
 165                 if version != null then target_dir += "=" + version
 166                 if installed.has(target_dir) then
 167                         # Ignore packages installed in this run
 168                         return
 169                 end
 170                 installed.add target_dir
 171
 172                 if target_dir.file_exists then
 173                         # Warn about packages previously installed,
 174                         # install dependencies anyway in case of a previous error.
 175                         print_error "Package '{name}' is already installed"
 176                 else
 177                         # Actually install it
 178                         var cmd_branch = ""
 179                         if version != null then cmd_branch = "--branch '{version}'"
 180
 181                         var cmd = "git clone --depth 1 {cmd_branch} {git_repo.escape_to_sh} {target_dir.escape_to_sh}"
 182                         if verbose then print "+ {cmd}"
 183
 184                         if "NIT_TESTING".environ == "true" then
 185                                 # Silence git output when testing
 186                                 cmd += " 2> /dev/null"
 187                         end
 188
 189                         var proc = new Process("sh", "-c", cmd)
 190                         proc.wait
 191
 192                         if proc.status != 0 then
 193                                 print_error "Install of '{name}' failed"
 194                                 exit 1
 195                         end
 196                 end
 197
 198                 # Recursive install
 199                 var ini = new ConfigTree(target_dir/"package.ini")
 200                 var import_line = ini["package.import"]
 201                 if import_line != null then
 202                         install_packages import_line
 203                 end
 204         end
 205 end
 206
 207 # Upgrade a package
 208 class CommandUpgrade
 209         super Command
 210
 211         redef fun name do return "upgrade"
 212         redef fun usage do return "nitpm upgrade <package>"
 213         redef fun description do return "Upgrade a package"
 214
 215         redef fun apply(args)
 216         do
 217                 if args.length != 1 then
 218                         print_local_help
 219                         exit 1
 220                 end
 221
 222                 var name = args.first
 223                 var target_dir = nitpm_lib_dir / name
 224
 225                 if not target_dir.file_exists or not target_dir.to_path.is_dir then
 226                         print_error "Package not found"
 227                         exit 1
 228                 end
 229
 230                 check_git
 231
 232                 var cmd = "cd {target_dir.escape_to_sh}; git pull"
 233                 if verbose then print "+ {cmd}"
 234
 235                 var proc = new Process("sh", "-c", cmd)
 236                 proc.wait
 237
 238                 if proc.status != 0 then
 239                         print_error "Upgrade failed"
 240                         exit 1
 241                 end
 242         end
 243 end
 244
 245 # Uninstall a package
 246 class CommandUninstall
 247         super Command
 248
 249         redef fun name do return "uninstall"
 250         redef fun usage do return "nitpm uninstall [-f] <package0>[=version] [package1 ...]"
 251         redef fun description do return "Uninstall packages"
 252
 253         redef fun apply(args)
 254         do
 255                 var opt_force = "-f"
 256                 var force = args.has(opt_force)
 257                 if force then args.remove(opt_force)
 258
 259                 if args.is_empty then
 260                         print_local_help
 261                         exit 1
 262                 end
 263
 264                 for name in args do
 265                         var target_dir = nitpm_lib_dir / name
 266
 267                         if not target_dir.file_exists or not target_dir.to_path.is_dir then
 268                                 print_error "Package not found"
 269                                 exit 1
 270                         end
 271
 272                         # Ask confirmation
 273                         if not force then
 274                                 var response = prompt("Delete {target_dir.escape_to_sh}? [Y/n] ")
 275                                 var accept = response != null and
 276                                         (response.to_lower == "y" or response.to_lower == "yes" or response == "")
 277                                 if not accept then return
 278                         end
 279
 280                         var cmd = "rm -rf {target_dir.escape_to_sh}"
 281                         if verbose then print "+ {cmd}"
 282
 283                         var proc = new Process("sh", "-c", cmd)
 284                         proc.wait
 285
 286                         if proc.status != 0 then
 287                                 print_error "Uninstall failed"
 288                                 exit 1
 289                         end
 290                 end
 291         end
 292 end
 293
 294 # List all installed packages
 295 class CommandList
 296         super Command
 297
 298         redef fun name do return "list"
 299         redef fun usage do return "nitpm list"
 300         redef fun description do return "List installed packages"
 301
 302         redef fun apply(args)
 303         do
 304                 var files = nitpm_lib_dir.files
 305                 var name_to_desc = new Map[String, nullable String]
 306                 var max_name_len = 0
 307
 308                 # Collect package info
 309                 for file in files do
 310                         var ini_path = nitpm_lib_dir / file / "package.ini"
 311                         if verbose then print "- Reading ini file at {ini_path}"
 312                         var ini = new ConfigTree(ini_path)
 313                         var tags = ini["package.tags"]
 314
 315                         name_to_desc[file] = tags
 316                         max_name_len = max_name_len.max(file.length)
 317                 end
 318
 319                 # Sort in alphabetical order
 320                 var sorted_names = name_to_desc.keys.to_a
 321                 alpha_comparator.sort sorted_names
 322
 323                 # Print with clear columns
 324                 for name in sorted_names do
 325                         var col0 = name.justify(max_name_len+1, 0.0)
 326                         var col1 = name_to_desc[name] or else ""
 327                         var line = col0 + col1
 328                         print line.trim
 329                 end
 330         end
 331 end
 332
 333 # Show general help or help specific to a command
 334 class CommandHelp
 335         super Command
 336
 337         redef fun name do return "help"
 338         redef fun usage do return "nitpm help [command]"
 339         redef fun description do return "Show general help message or the help for a command"
 340
 341         redef fun apply(args)
 342         do
 343                 # Try first to help about a valid action
 344                 if args.length == 1 then
 345                         var command = commands.get_or_null(args.first)
 346                         if command != null then
 347                                 command.print_local_help
 348                                 return
 349                         end
 350                 end
 351
 352                 print_help
 353         end
 354 end
 355
 356 redef class Sys
 357
 358         # General command line options
 359         var opts = new OptionContext
 360
 361         # Help option
 362         var opt_help = new OptionBool("Show this help message", "--help", "-h")
 363
 364         # Verbose mode option
 365         var opt_verbose = new OptionBool("Print more information", "--verbose", "-v")
 366         private fun verbose: Bool do return opt_verbose.value
 367
 368         # All command line actions, mapped to their short `name`
 369         var commands = new Map[String, Command]
 370
 371         private var command_install = new CommandInstall(commands)
 372         private var command_list = new CommandList(commands)
 373         private var command_update = new CommandUpgrade(commands)
 374         private var command_uninstall = new CommandUninstall(commands)
 375         private var command_help = new CommandHelp(commands)
 376 end
 377
 378 redef fun nitpm_lib_dir
 379 do
 380         if "NIT_TESTING".environ == "true" then
 381                 return "/tmp/nitpm-test-" + "NIT_TESTING_ID".environ
 382         else return super
 383 end
 384
 385 # Print the general help message
 386 private fun print_help
 387 do
 388         print "usage: nitpm <command> [options]"
 389         print ""
 390
 391         print "commands:"
 392         for command in commands.values do
 393                 print "  {command.name.justify(11, 0.0)} {command.description}"
 394         end
 395         print ""
 396
 397         print "options:"
 398         opts.usage
 399 end
 400
 401 # Check if `git` is available, exit if not
 402 private fun check_git
 403 do
 404         var proc = new ProcessReader("git", "--version")
 405         proc.wait
 406         proc.close
 407
 408         if proc.status != 0 then
 409                 print_error "Please install `git`"
 410                 exit 1
 411         end
 412 end
 413
 414 # Parse main options
 415 opts.add_option(opt_help, opt_verbose)
 416 opts.parse
 417 var rest = opts.rest
 418
 419 if opt_help.value then
 420         print_help
 421         exit 0
 422 end
 423
 424 if opts.errors.not_empty then
 425         for error in opts.errors do print error
 426         print ""
 427         print_help
 428         exit 1
 429 end
 430
 431 if rest.is_empty then
 432         print_help
 433         exit 1
 434 end
 435
 436 # Find and apply action
 437 var action_name = rest.shift
 438 var action = commands.get_or_null(action_name)
 439 if action != null then
 440         action.apply rest
 441 else
 442         print_help
 443         exit 1
 444 end