src/toolcontext.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2006-2008 Floréal Morandat <morandat@lirmm.fr>
   4 # Copyright 2008-2012 Jean Privat <jean@pryen.org>
   5 # Copyright 2009 Jean-Sebastien Gelinas <calestar@gmail.com>
   6 # Copyright 2014 Alexandre Terrasa <alexandre@moz-code.org>
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License");
   9 # you may not use this file except in compliance with the License.
  10 # You may obtain a copy of the License at
  11 #
  12 #     http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS,
  16 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 # See the License for the specific language governing permissions and
  18 # limitations under the License.
  19
  20 # Common command-line tool infrastructure than handle options and error messages
  21 module toolcontext
  22
  23 import opts
  24 import location
  25 import version
  26 import template
  27
  28 # A warning or an error
  29 class Message
  30         super Comparable
  31         redef type OTHER: Message
  32
  33         # The origin of the message in the source code, if any.
  34         var location: nullable Location
  35
  36         # The category of the message.
  37         #
  38         # Used by quality-control tool for statistics or to enable/disable things individually.
  39         var tag: nullable String
  40
  41         # The human-readable description of the message.
  42         #
  43         # It should be short and fit on a single line.
  44         # It should also have meaningful information first in case
  45         # on truncation by an IDE for instance.
  46         var text: String
  47
  48         # Comparisons are made on message locations.
  49         redef fun <(other: OTHER): Bool do
  50                 if location == null then return true
  51                 if other.location == null then return false
  52
  53                 return location.as(not null) < other.location.as(not null)
  54         end
  55
  56         redef fun to_s: String
  57         do
  58                 var l = location
  59                 if l == null then
  60                         return text
  61                 else
  62                         return "{l}: {text}"
  63                 end
  64         end
  65
  66         fun to_color_string: String
  67         do
  68                 var esc = 27.ascii
  69                 var red = "{esc}[0;31m"
  70                 var bred = "{esc}[1;31m"
  71                 var green = "{esc}[0;32m"
  72                 var yellow = "{esc}[0;33m"
  73                 var def = "{esc}[0m"
  74
  75                 var tag = tag
  76                 if tag != null then
  77                         tag = " ({tag})"
  78                 else
  79                         tag = ""
  80                 end
  81                 var l = location
  82                 if l == null then
  83                         return "{text}{tag}"
  84                 else if l.file == null then
  85                         return "{yellow}{l}{def}: {text}{tag}"
  86                 else
  87                         return "{yellow}{l}{def}: {text}{tag}\n{l.colored_line("1;31")}"
  88                 end
  89         end
  90 end
  91
  92 # Global context for tools
  93 class ToolContext
  94         # Number of errors
  95         var error_count: Int = 0
  96
  97         # Number of warnings
  98         var warning_count: Int = 0
  99
 100         # Directory where to generate log files
 101         var log_directory: String = "logs"
 102
 103         # Messages
 104         private var messages: Array[Message] = new Array[Message]
 105         private var message_sorter: ComparableSorter[Message] = new ComparableSorter[Message]
 106
 107         fun check_errors
 108         do
 109                 if messages.length > 0 then
 110                         message_sorter.sort(messages)
 111
 112                         for m in messages do
 113                                 if opt_no_color.value then
 114                                         sys.stderr.write("{m}\n")
 115                                 else
 116                                         sys.stderr.write("{m.to_color_string}\n")
 117                                 end
 118                         end
 119
 120                         messages.clear
 121                 end
 122
 123                 if error_count > 0 then
 124                         errors_info
 125                         exit(1)
 126                 end
 127         end
 128
 129         # Display total error informations
 130         fun errors_info
 131         do
 132                 if error_count == 0 and warning_count == 0 then return
 133                 if opt_no_color.value then return
 134                 sys.stderr.write "Errors: {error_count}. Warnings: {warning_count}.\n"
 135         end
 136
 137         # Display an error
 138         fun error(l: nullable Location, s: String)
 139         do
 140                 messages.add(new Message(l,null,s))
 141                 error_count = error_count + 1
 142                 if opt_stop_on_first_error.value then check_errors
 143         end
 144
 145         # Add an error, show errors and quit
 146         fun fatal_error(l: nullable Location, s: String)
 147         do
 148                 error(l,s)
 149                 check_errors
 150         end
 151
 152         # Display a warning
 153         fun warning(l: nullable Location, tag: String, text: String)
 154         do
 155                 if opt_warn.value == 0 then return
 156                 messages.add(new Message(l, tag, text))
 157                 warning_count = warning_count + 1
 158                 if opt_stop_on_first_error.value then check_errors
 159         end
 160
 161         # Display an info
 162         fun info(s: String, level: Int)
 163         do
 164                 if level <= verbose_level then
 165                         print "{s}"
 166                 end
 167         end
 168
 169         # Executes a program while checking if it's available and if the execution ended correctly
 170         #
 171         # Stops execution and prints errors if the program isn't available or didn't end correctly
 172         fun exec_and_check(args: Array[String], error: String)
 173         do
 174                 var prog = args.first
 175                 args.remove_at 0
 176
 177                 # Is the wanted program available?
 178                 var proc_which = new IProcess.from_a("which", [prog])
 179                 proc_which.wait
 180                 var res = proc_which.status
 181                 if res != 0 then
 182                         print "{error}: executable \"{prog}\" not found"
 183                         exit 1
 184                 end
 185
 186                 # Execute the wanted program
 187                 var proc = new Process.from_a(prog, args)
 188                 proc.wait
 189                 res = proc.status
 190                 if res != 0 then
 191                         print "{error}: execution of \"{prog} {args.join(" ")}\" failed"
 192                         exit 1
 193                 end
 194         end
 195
 196         # Global OptionContext
 197         var option_context: OptionContext = new OptionContext
 198
 199         # Option --warn
 200         var opt_warn: OptionCount = new OptionCount("Show warnings", "-W", "--warn")
 201
 202         # Option --quiet
 203         var opt_quiet: OptionBool = new OptionBool("Do not show warnings", "-q", "--quiet")
 204
 205         # Option --log
 206         var opt_log: OptionBool = new OptionBool("Generate various log files", "--log")
 207
 208         # Option --log-dir
 209         var opt_log_dir: OptionString = new OptionString("Directory where to generate log files", "--log-dir")
 210
 211         # Option --help
 212         var opt_help: OptionBool = new OptionBool("Show Help (This screen)", "-h", "-?", "--help")
 213
 214         # Option --version
 215         var opt_version: OptionBool = new OptionBool("Show version and exit", "--version")
 216
 217         # Option --set-dummy-tool
 218         var opt_set_dummy_tool: OptionBool = new OptionBool("Set toolname and version to DUMMY. Useful for testing", "--set-dummy-tool")
 219
 220         # Option --verbose
 221         var opt_verbose: OptionCount = new OptionCount("Verbose", "-v", "--verbose")
 222
 223         # Option --stop-on-first-error
 224         var opt_stop_on_first_error: OptionBool = new OptionBool("Stop on first error", "--stop-on-first-error")
 225
 226         # Option --no-color
 227         var opt_no_color: OptionBool = new OptionBool("Do not use color to display errors and warnings", "--no-color")
 228
 229         # Option --bash-completion
 230         var opt_bash_completion: OptionBool = new OptionBool("Generate bash_completion file for this program", "--bash-completion")
 231
 232         # Verbose level
 233         var verbose_level: Int = 0
 234
 235         init
 236         do
 237                 option_context.add_option(opt_warn, opt_quiet, opt_stop_on_first_error, opt_no_color, opt_log, opt_log_dir, opt_help, opt_version, opt_set_dummy_tool, opt_verbose, opt_bash_completion)
 238         end
 239
 240         # Name, usage and synopsis of the tool.
 241         # It is mainly used in `usage`.
 242         # Should be correctly set by the client before calling `process_options`
 243         # A multi-line string is recommmended.
 244         #
 245         # eg. `"Usage: tool [OPTION]... [FILE]...\nDo some things."`
 246         var tooldescription: String = "Usage: [OPTION]... [ARG]..." is writable
 247
 248         # Does `process_options` should accept an empty sequence of arguments.
 249         # ie. nothing except options.
 250         # Is `false` by default.
 251         #
 252         # If required, if should be set by the client before calling `process_options`
 253         var accept_no_arguments = false is writable
 254
 255         # print the full usage of the tool.
 256         # Is called by `process_option` on `--help`.
 257         # It also could be called by the client.
 258         fun usage
 259         do
 260                 print tooldescription
 261                 option_context.usage
 262         end
 263
 264         # Parse and process the options given on the command line
 265         fun process_options(args: Sequence[String])
 266         do
 267                 self.opt_warn.value = 1
 268
 269                 # init options
 270                 option_context.parse(args)
 271
 272                 if opt_help.value then
 273                         usage
 274                         exit 0
 275                 end
 276
 277                 if opt_version.value then
 278                         print version
 279                         exit 0
 280                 end
 281
 282                 if opt_bash_completion.value then
 283                         var bash_completion = new BashCompletion(self)
 284                         bash_completion.write_to(sys.stdout)
 285                         exit 0
 286                 end
 287
 288                 var errors = option_context.get_errors
 289                 if not errors.is_empty then
 290                         for e in errors do print "Error: {e}"
 291                         print tooldescription
 292                         print "Use --help for help"
 293                         exit 1
 294                 end
 295
 296                 if option_context.rest.is_empty and not accept_no_arguments then
 297                         print tooldescription
 298                         print "Use --help for help"
 299                         exit 1
 300                 end
 301
 302                 # Set verbose level
 303                 verbose_level = opt_verbose.value
 304
 305                 if self.opt_quiet.value then self.opt_warn.value = 0
 306
 307                 if opt_log_dir.value != null then log_directory = opt_log_dir.value.as(not null)
 308                 if opt_log.value then
 309                         # Make sure the output directory exists
 310                         log_directory.mkdir
 311                 end
 312
 313                 nit_dir = compute_nit_dir
 314         end
 315
 316         # Get the current `nit_version` or "DUMMY_VERSION" if `--set-dummy-tool` is set.
 317         fun version: String do
 318                 if opt_set_dummy_tool.value then
 319                         return "DUMMY_VERSION"
 320                 end
 321                 return nit_version
 322         end
 323
 324         # Get the name of the tool or "DUMMY_TOOL" id `--set-dummy-tool` is set.
 325         fun toolname: String do
 326                 if opt_set_dummy_tool.value then
 327                         return "DUMMY_TOOL"
 328                 end
 329                 return sys.program_name.basename("")
 330         end
 331
 332         # The identified root directory of the Nit project
 333         var nit_dir: nullable String = null
 334
 335         private fun compute_nit_dir: nullable String
 336         do
 337                 # a environ variable has precedence
 338                 var res = "NIT_DIR".environ
 339                 if not res.is_empty then return res
 340
 341                 # find the runpath of the program from argv[0]
 342                 res = "{sys.program_name.dirname}/.."
 343                 if res.file_exists and "{res}/src/nit.nit".file_exists then return res.simplify_path
 344
 345                 # find the runpath of the process from /proc
 346                 var exe = "/proc/self/exe"
 347                 if exe.file_exists then
 348                         res = exe.realpath
 349                         res = res.dirname.join_path("..")
 350                         if res.file_exists and "{res}/src/nit.nit".file_exists then return res.simplify_path
 351                 end
 352
 353                 return null
 354         end
 355 end
 356
 357 # This class generates a compatible `bash_completion` script file.
 358 #
 359 # On some Linux systems `bash_completion` allow the program to control command line behaviour.
 360 #
 361 #       $ nitls [TAB][TAB]
 362 #       file1.nit              file2.nit              file3.nit
 363 #
 364 #       $ nitls --[TAB][TAB]
 365 #       --bash-toolname        --keep                 --path                 --tree
 366 #       --depends              --log                  --project              --verbose
 367 #       --disable-phase        --log-dir              --quiet                --version
 368 #       --gen-bash-completion  --no-color             --recursive            --warn
 369 #       --help                 --only-metamodel       --source
 370 #       --ignore-visibility    --only-parse           --stop-on-first-error
 371 #
 372 # Generated file can be placed in system bash_completion directory `/etc/bash_completion.d/`
 373 # or source it in `~/.bash_completion`.
 374 class BashCompletion
 375         super Template
 376
 377         var toolcontext: ToolContext
 378
 379         init(toolcontext: ToolContext) do
 380                 self.toolcontext = toolcontext
 381         end
 382
 383         private fun extract_options_names: Array[String] do
 384                 var names = new Array[String]
 385                 for option in toolcontext.option_context.options do
 386                         for name in option.names do
 387                                 if name.has_prefix("--") then names.add name
 388                         end
 389                 end
 390                 return names
 391         end
 392
 393         redef fun rendering do
 394                 var name = toolcontext.toolname
 395                 var option_names = extract_options_names
 396                 addn "# generated bash completion file for {name} {toolcontext.version}"
 397                 addn "_{name}()"
 398                 addn "\{"
 399                 addn "  local cur prev opts"
 400                 addn "  COMPREPLY=()"
 401                 addn "  cur=\"$\{COMP_WORDS[COMP_CWORD]\}\""
 402                 addn "  prev=\"$\{COMP_WORDS[COMP_CWORD-1]\}\""
 403                 if option_names != null then
 404                         addn "  opts=\"{option_names.join(" ")}\""
 405                         addn "  if [[ $\{cur\} == -* ]] ; then"
 406                         addn "          COMPREPLY=( $(compgen -W \"$\{opts\}\" -- $\{cur\}) )"
 407                         addn "          return 0"
 408                         addn "  fi"
 409                 end
 410                 addn "\} &&"
 411                 addn "complete -o default -F _{name} {name}"
 412         end
 413 end