tty-exit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 90291ac39f6262d62023d9466a8f79edca9b001072c68cb60799ea45d462bf02
+  data.tar.gz: f9c7422bedb2eef073fe21636842a8e60914497fb2800ad1d14819a8da29b600
+SHA512:
+  metadata.gz: bbfc7bd556613417a2ee20411033040ad438cfde2bec149435d46e7541b81aa9e5ee31d4dc3045b5410c4e5fb86db0baa1cd359de933e95a1c97631a8550c64f
+  data.tar.gz: 11a3cc9803ca5b1ac3eac8f2eaf5e3e4648e87c20eaac5854855e0e4fb0dd7961cccda02bfcb3ef49ec96d96b97ad7777a64ef1055948afa344bcd78ed7d755a

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## [v0.1.0] - 2020-01-xx
+
+* Initial implementation and release
+
+[v0.1.0]: https://github.com/piotrmurach/tty-exit/compare/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Piotr Murach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,297 @@
+<div align="center">
+  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://cdn.rawgit.com/piotrmurach/tty/master/images/tty.png" alt="tty logo" /></a>
+</div>
+
+# TTY::Exit [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+
+[![Gem Version](https://badge.fury.io/rb/tty-exit.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/piotrmurach/tty-exit.svg?branch=master)][travis]
+[![Build status](https://ci.appveyor.com/api/projects/status/rtm3po27ouarfrhf?svg=true)][appveyor]
+[![Code Climate](https://codeclimate.com/github/piotrmurach/tty-exit/badges/gpa.svg)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/tty-exit/badge.svg)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/tty-exit.svg?branch=master)][inchpages]
+
+[gitter]: https://gitter.im/piotrmurach/tty
+[gem]: http://badge.fury.io/rb/tty-exit
+[travis]: http://travis-ci.org/piotrmurach/tty-exit
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-exit
+[codeclimate]: https://codeclimate.com/github/piotrmurach/tty-exit
+[coverage]: https://coveralls.io/github/piotrmurach/tty-exit
+[inchpages]: http://inch-ci.org/github/piotrmurach/tty-exit
+
+> Terminal exit codes for humans and machines.
+
+The goal of this library is to provide human friendly and standard way to use exit status codes in command line applications. Instead of saying `exit(64)`, you can say `exit_with(:usage_error)`. Both indicate a failure to the parent process but the `:usage_error` is so much nicer! Wouldn't you agree? That's why `tty-exit` gathers a list of all the most common exit codes as used by POSIX-compliant tools on different Unix systems for you to use.
+
+The exit statuses range from 0 to 255 (inclusive). Any other exit status than 0 indicates a failure of some kind. The exit codes in the range 64-78 are adapted from the OpenBSD [sysexits.h](https://man.openbsd.org/sysexits.3). The codes between 125 and 128 are reserved for shell statuses as defined in [Advanced Bash Scripting Guide, Appendix E](http://tldp.org/LDP/abs/html/exitcodes.html). The codes in the 129-154 range correspond with the fatal signals as defined in [signal](https://man.openbsd.org/signal.3).
+
+**TTY::Exit** provides independent terminal exit codes component for [TTY](https://github.com/piotrmurach/tty) toolkit.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tty-exit'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install tty-exit
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. API](#2-api)
+  * [2.1 exit_code](#21-exit_code)
+  * [2.2 exit_message](#22-exit_message)
+  * [2.3 exit_with](#23-exit_with)
+  * [2.4 register_exit](#24-register_exit)
+  * [2.5 exit_reserved?](#25-exit_reserved)
+  * [2.6 exit_valid?](#26-exit_valid)
+  * [2.7 exit_success?](#27-exit_success)
+  * [2.8 exit_codes](#28-exit_codes)
+  * [2.9 exit_messages](#29-exit_messages)
+
+## 1. Usage
+
+To exit from any program use `exit_with` method. Instead of a number, you can use a readable name for the exit status:
+
+```ruby
+TTY::Exit.exit_with(:usage_error)
+```
+
+The above will exit program immediately with an exit code indicating a failure:
+
+```ruby
+puts $?.exitstatus
+# => 64
+```
+
+All the reserved exit statuses have a matching exit message. To display a default message, as a second argument to `exit_with` you can pass `:default` value:
+
+```ruby
+TTY::Exit.exit_with(:usage_error, :default)
+```
+
+That will produce the following user friendly message:
+
+```ruby
+# => "ERROR(64): Command line usage error"
+```
+
+The preferred way is to include **TTY::Exit** module in your code:
+
+```ruby
+class Command
+  include TTY::Exit
+
+  def execute
+    exit_with(:config_error, :default)
+  end
+end
+```
+
+This will print an error message and return appropriate exit status:
+
+```ruby
+cmd = Command.new
+cmd.execute
+# => "ERROR(78): Configuration Error"
+puts $?.exitstatus
+# => 78
+```
+
+To see the full list of reserved exit codes go to [2.8 exit_codes](#28-exit-codes) section.
+
+## 2. API
+
+### 2.1 exit_code
+
+There are many built-in exit codes that can be referenced using a name.
+
+For example to return an exit code denoting success, you can use `:ok` or `:success`:
+
+```ruby
+TTY::Exit.exit_code(:ok) # => 0
+TTY::Exit.exit_code(:success) # => 0
+```
+
+Any other exit status than 0 indicates a failure of some kind. For example, when a command cannot be found use `:not_found`:
+
+```ruby
+TTY::Exit.exit_code(:not_found)
+# => 127
+```
+
+You can also use an exit code directly:
+
+```ruby
+TTY::Exit.exit_code(127)
+# => 127
+```
+
+### 2.2 exit_message
+
+One of the downsides of exit codes is that they are not very communicative to the user. Why not have both? An exit code and a user friendly message. That's what `exit_message` is for. All the reserved exit codes have corresponding user friendly messages.
+
+For example, when returning exit code `64` for usage error:
+
+```ruby
+TTY::Exit.exit_message(:usage_error)
+TTY::Exit.exit_message(64)
+```
+
+Will return:
+
+```ruby
+# => "ERROR(64): Command line usage error"
+```
+
+The default messages are used by the `exit_with` method and can be overwritten by a custom one.
+
+### 2.3 exit_with
+
+To exit program with an exit code use `exit_with`. This method accepts a name or a code for the exit status. 
+
+```ruby
+TTY::Exit.exit_with(:usage_error)
+TTY::Exit.exit_with(64)
+```
+
+Both will produce the same outcome.
+
+As a second argument you can specify a user friendly message to be printed to `stderr` before exit. To use predefined messages use `:default` as a value:
+
+```ruby
+TTY::Exit.exit_with(:usage_error, :default)
+# => "ERROR(64): Command line usage error"
+```
+
+Optionally, you can provide a custom message to display to the user.
+
+```ruby
+TTY::Exit.exit_with(:usge_error, "Wrong arguments")
+# => "Wrong arguments"
+```
+
+Finally, you can redirect output to a different stream using `:io` option. By default, message is printed to `stderr`:
+
+```ruby
+TTY::Exit.exit_with(:usage_error, io: $stdout)
+```
+
+Since `TTY::Exit` is a module, you can include it in your code to get access to all the methods:
+
+```ruby
+class Command
+  include TTY::Exit
+
+  def execute
+    exit_with(:usage_error, :default)
+  end
+end
+```
+
+### 2.4 register_exit
+
+If the provided exit codes don't match your needs, you can add your own using the `register_exit` method. 
+
+For example, to register a custom exit with `:too_long` name and the status `7` that will notify user and programs about too many arguments do:
+
+```ruby
+class Command
+  include TTY::Exit
+
+  register_exit(:too_long, 7, "Argument list too long")
+
+  def execute
+    exit_with(:too_long, :default)
+  end
+end
+```
+
+Then when the command gets run:
+
+```ruby
+cmd = Command.new
+cmd.execute
+# =>
+# ERROR(7): Argument list too long
+```
+
+### 2.5 exit_reserved?
+
+To check if an exit code is already reserved by Unix system use `exit_reserved?`. This is useful in situations where you want to add it your command line application custom exit codes. The check accepts only integer numbers in range 0 to 255 inclusive:
+
+```ruby
+TTY::Exit.exit_reserved?(126) # => true
+TTY::Exit.exit_reserved?(100) # => false
+```
+
+### 2.6 exit_valid?
+
+The exit statuses range from 0 to 255 (inclusive). The `exit_valid?` method helps you check if an exit status is within the range or not.
+
+```ruby
+TTY::Exit.exit_valid?(11) # => true
+TTY::Exit.exit_valid?(522) # => false
+```
+
+### 2.7 exit_success?
+
+Any other exit status than 0 indicates a failure of some kind. The `exit_success?` is a more descriptive way to determine if a program succeeded or not.
+
+```ruby
+TTY::Exit.exit_success?(0) # => true
+TTY::Exit.exit_success?(7) # => false
+```
+
+### 2.8 exit_codes
+
+You can access all the predefined exit codes and their names with `exit_codes` method:
+
+```ruby
+TTY::Exit.exit_codes
+# =>
+# "{:ok=>0, :success=>0, :error=>1, :shell_misuse=>2, :usage_error=>64, :data_error=>65, ... }"
+```
+
+### 2.9 exit_messages
+
+To see what default messages are for the predefined exit codes use `exit_messages`:
+
+```ruby
+TTY::Exit.exit_messages
+# =>
+# "{0=>"Successful termination", 1=>"An error occurred", 2=>"Misuse of shell builtins", 64=>"Command line usage error", ... }"
+```
+
+The exit statuses range from 0 to 255 (inclusive). Any other exit status than 0 indicates a failure of some kind. The exit codes in the range 64-78 are adapted from the OpenBSD [sysexits.h](https://man.openbsd.org/sysexits.3). The codes between 125 and 128 are reserved for shell statuses as defined in [Advanced Bash Scripting Guide, Appendix E](http://tldp.org/LDP/abs/html/exitcodes.html). The codes in the 129-154 range correspond with the fatal signals as defined in [signal](https://man.openbsd.org/signal.3).
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/tty-exit. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/piotrmurach/tty-exit/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TTY::Exit project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-exit/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright (c) 2020 Piotr Murach. See LICENSE for further details.

data/lib/tty-exit.rb

@@ -0,0 +1 @@
+require_relative "tty/exit"

data/lib/tty/exit.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "exit/code"
+require_relative "exit/registry"
+require_relative "exit/version"
+
+module TTY
+  # Terminal exit codes for humans and machines
+  module Exit
+    extend self
+
+    Error = Class.new(StandardError)
+
+    # @api private
+    def self.included(base)
+      base.instance_eval do
+        def register_exit(*args)
+          Registry.register_exit(*args)
+        end
+      end
+    end
+
+    NAME_TO_EXIT_CODE = {
+      ok: Code::SUCCESS,
+      success: Code::SUCCESS,
+      error: Code::ERROR,
+      shell_misuse: Code::SHELL_MISUSE,
+
+      usage_error: Code::USAGE_ERROR,
+      data_err: Code::DATA_ERROR,
+      data_error: Code::DATA_ERROR,
+      no_input: Code::NO_INPUT,
+      no_user: Code::NO_USER,
+      no_host: Code::NO_HOST,
+      service_unavailable: Code::SERVICE_UNAVAILABLE,
+      software_error: Code::SOFTWARE_ERROR,
+      system_error: Code::SYSTEM_ERROR,
+      system_file_missing: Code::SYSTEM_FILE_MISSING,
+      cant_create: Code::CANT_CREATE,
+      io_error: Code::IO_ERROR,
+      io_err: Code::IO_ERROR,
+      temp_fail: Code::TEMP_FAIL,
+      protocol: Code::PROTOCOL,
+      no_perm: Code::NO_PERM,
+      no_permission: Code::NO_PERM,
+      config_error: Code::CONFIG_ERROR,
+      configuration_error: Code::CONFIG_ERROR,
+
+      cannot_execute: Code::CANNOT_EXECUTE,
+      not_found: Code::COMMAND_NOT_FOUND,
+      command_not_found: Code::COMMAND_NOT_FOUND,
+      invalid_argument: Code::INVALID_ARGUMENT,
+
+      hangup: Code::HANGUP,
+      interrupt: Code::INTERRUPT,
+      quit: Code::QUIT,
+      illegal_instruction: Code::ILLEGAL_INSTRUCTION,
+      trace_trap: Code::TRACE_TRAP,
+      abort: Code::ABORT,
+      kill: Code::KILL,
+      bus_error: Code::BUS_ERROR,
+      memory_error: Code::MEMORY_ERROR,
+      segmentation_fault: Code::MEMORY_ERROR,
+      pipe: Code::PIPE,
+      alarm: Code::ALARM,
+      user1: Code::USER1,
+      user2: Code::USER2
+    }.freeze
+    private_constant :NAME_TO_EXIT_CODE
+
+    CODE_TO_EXIT_MESSAGE = {
+      Code::SUCCESS => "Successful termination",
+      Code::ERROR => "An error occurred",
+      Code::SHELL_MISUSE => "Misuse of shell builtins",
+
+      Code::USAGE_ERROR => "Command line usage error",
+      Code::DATA_ERROR => "Data format error",
+      Code::NO_INPUT => "Cannot open input",
+      Code::NO_USER => "User name unknown",
+      Code::NO_HOST => "Host name unknown",
+      Code::SERVICE_UNAVAILABLE => "Service unavailable",
+      Code::SOFTWARE_ERROR => "Internal software error",
+      Code::SYSTEM_ERROR => "System error (e.g. can't fork)",
+      Code::SYSTEM_FILE_MISSING => "Critical OS file missing",
+      Code::CANT_CREATE => "Can't create user output file",
+      Code::IO_ERROR => "Input/output error",
+      Code::TEMP_FAIL => "Temp failure, user is invited to retry",
+      Code::PROTOCOL => "Remote error in protocol",
+      Code::NO_PERM => "Permission denied",
+      Code::CONFIG_ERROR => "Configuration error",
+
+      Code::CANNOT_EXECUTE => "Command invoked cannot execute",
+      Code::COMMAND_NOT_FOUND => "Command not found",
+      Code::INVALID_ARGUMENT => "Invalid argument",
+
+      Code::HANGUP => "Hangup detected on controlling terminal or death of controlling process.",
+      Code::INTERRUPT => "Interrupted by Control-C",
+      Code::QUIT => "Quit program",
+      Code::ILLEGAL_INSTRUCTION => "Illegal instruction",
+      Code::TRACE_TRAP => "Trace/breakpoint trap",
+      Code::ABORT => "Abort program",
+      Code::KILL => "Kill program",
+      Code::BUS_ERROR => "Access to an undefined portion of a memory object",
+      Code::MEMORY_ERROR => "An invalid virtual memory reference or segmentation fault",
+      Code::PIPE => "Write on a pipe with no one to read it",
+      Code::ALARM => "Alarm clock",
+      Code::USER1 => "User-defined signal 1",
+      Code::USER2 => "User-defined signal 2"
+    }.freeze
+    private_constant :CODE_TO_EXIT_MESSAGE
+
+    # Check if an exit code is valid, that it's within the 0-255 (inclusive)
+    #
+    # @param [Integer] code
+    #   the code to check
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def exit_valid?(code)
+      code >= 0 && code <= 255
+    end
+
+    # Check if an exit code is already defined by Unix system
+    #
+    # @param [Integer] code
+    #   the code to check
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def exit_reserved?(code)
+      (code >= Code::SUCCESS && code <= Code::SHELL_MISUSE) ||
+        (code >= Code::USAGE_ERROR && code <= Code::CONFIG_ERROR) ||
+        (code >= Code::CANNOT_EXECUTE && code <= Code::USER2)
+    end
+
+    # Check if the exit status was successful.
+    #
+    # @param [Integer] code
+    #
+    # @api public
+    def exit_success?(code)
+      code == Code::SUCCESS
+    end
+
+    # A user friendly explanation of the exit code
+    #
+    # @example
+    #   TTY::Exit.exit_message(:usage_error)
+    #   # => "Command line usage error"
+    #
+    # @param [String,Integer] name_or_code
+    #
+    # @api public
+    def exit_message(name_or_code = :ok)
+      (Registry.exits[name_or_code] || {})[:message] ||
+        CODE_TO_EXIT_MESSAGE[exit_code(name_or_code)] || ""
+    end
+
+    # Provide a list of reserved status messages
+    #
+    # @api public
+    def exit_messages
+      CODE_TO_EXIT_MESSAGE
+    end
+
+    # Provide exit code for a name or status
+    #
+    # @example
+    #   TTY::Exit.exit_code(:usage_error)
+    #   # => 64
+    #
+    # @param [String,Integer] name_or_code
+    #
+    # @return [Integer]
+    #   the exit code
+    #
+    # @api public
+    def exit_code(name_or_code = :ok)
+      case name_or_code
+      when String, Symbol
+        (Registry.exits[name_or_code.to_sym] || {})[:code] ||
+          NAME_TO_EXIT_CODE.fetch(name_or_code.to_sym) do
+            raise Error, "Name '#{name_or_code}' isn't recognized."
+          end
+      when Numeric
+        if exit_valid?(name_or_code.to_i)
+          name_or_code.to_i
+        else
+          raise Error, "Provided code outside of the range (0 - 255)"
+        end
+      else
+        raise Error, "Provide a name or a number as an exit code"
+      end
+    end
+
+    # Provide a list of reserved codes
+    #
+    # @api public
+    def exit_codes
+      NAME_TO_EXIT_CODE
+    end
+
+    # Exit this process with a given status code
+    #
+    # @param [String,Integer] name_or_code
+    #   The name for an exit code or code itself
+    # @param [String] message
+    #   The message to print to io stream
+    # @param [IO] io
+    #   The io to print message to
+    #
+    # @return [nil]
+    #
+    # @api public
+    def exit_with(name_or_code = :ok, message = nil, io: $stderr)
+      if message == :default
+        message = "ERROR(#{exit_code(name_or_code)}): #{exit_message(name_or_code)}"
+      end
+      io.print(message) if message
+      ::Kernel.exit(exit_code(name_or_code))
+    end
+  end # Exit
+end # TTY

data/lib/tty/exit/code.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module TTY
+  module Exit
+    # All reserved exit codes as constants
+    module Code
+      # No errors
+      SUCCESS = 0
+
+      # Catchall for general errors
+      ERROR = 1
+
+      # Missing keyword or command, or permission problem
+      # (and diff return code on a failed binary file comparison).
+      SHELL_MISUSE = 2
+
+      # The start base code to reduce possibility of clashing with other
+      # exit statuses that programs may already run.
+      BASE = 64
+
+      # The command was used incorrectly, e.g., with the wrong number
+      # of arguments, a bad flag, a bad syntax in a parameter, or whatever.
+      USAGE_ERROR = BASE # 64
+
+      # The input data was incorrect in some way.
+      # This should only be used for user's data & not system files.
+      DATA_ERROR = BASE + 1 # 65
+
+      # An input file (not a system file) did not exist or was not readable.
+      NO_INPUT = BASE + 2 # 66
+
+      # The user specified did not exist. This might be used for mail
+      # addresses or remote logins.
+      NO_USER = BASE + 3 # 67
+
+      # The host specified did not exist. This is used in mail addresses
+      # or network requests.
+      NO_HOST = BASE + 4 # 68
+
+      # A service is unavailable. This can occur if a support program
+      # or file does not exist. This can also be used as a catchall
+      # message when something you wanted to do doesn't work,
+      # but you don't know why.
+      SERVICE_UNAVAILABLE = BASE + 5 # 69
+
+      # An internal software error has been detected. This should be
+      # limited to non-operating system related errors as possible.
+      SOFTWARE_ERROR = BASE + 6 # 70
+
+      # An operating system error has been detected. This is intended
+      # to be used for such things as "cannot fork", "cannot create pipe",
+      # or the like. It includes things like getuid returning a user that
+      # does not exist in the passwd file.
+      SYSTEM_ERROR = BASE + 7 # 71
+
+      # Some system file (e.g., /etc/passwd, /etc/utmp, etc.) does not exist,
+      # cannot be opened, or has some sort of error (e.g., syntax error).
+      SYSTEM_FILE_MISSING = BASE + 8 #72
+
+      # A (user specified) output file cannot be created.
+      CANT_CREATE = BASE + 9 # 73
+
+      # An error occurred while doing I/O on some file.
+      IO_ERROR = BASE + 10 # 74
+
+      # Temporary failure, indicating something that is not really an error.
+      # For example that a mailer could not create a connection, and the
+      # request should be reattempted later.
+      TEMP_FAIL = BASE + 11 # 75
+
+      # The remote system returned something that was 'not possible' during
+      # a protocol exchange.
+      PROTOCOL = BASE + 12 # 76
+
+      # You did not have sufficient permission to perform the operation.
+      # This is not intended for file system problems, which should use
+      # NO_INPUT or CANT_CREATE, but rather for higher level permissions.
+      NO_PERM = BASE + 13 # 77
+
+      # Something was found in an unconfigured or misconfigured state.
+      CONFIG_ERROR = BASE + 14 # 78
+
+      # Command invoked cannot execute. This may be due to permission
+      # issues.
+      CANNOT_EXECUTE = 126
+
+      # "command not found", possible typos in shell command or
+      # unrecognized characters
+      COMMAND_NOT_FOUND = 127
+
+      # The start base code for the system interrupt signals.
+      SIGNAL_BASE = 128
+
+      # Exit takes only integer args in the range 0 - 255,
+      # e.g. exit 3.14159 is invalid.
+      INVALID_ARGUMENT = SIGNAL_BASE
+
+      # This indicates that program received SIGHUP signal.
+      # It means that the controlling pseudo or virtual terminal
+      # has been closed.
+      HANGUP = SIGNAL_BASE + 1 # 129
+
+      # This indicates that program received SIGINT signal.
+      # An interrupt signal that by default this causes the
+      # process to terminate.
+      INTERRUPT = SIGNAL_BASE + 2 # 130
+
+      # This indicates that program received SIGQUIT signal.
+      QUIT = SIGNAL_BASE + 3 # 131
+
+      # This indicates that program received SIGQUIT signal.
+      ILLEGAL_INSTRUCTION = SIGNAL_BASE + 4 # 132
+
+      # This indicates that program received SIGTRAP signal.
+      TRACE_TRAP = SIGNAL_BASE + 5 # 133
+
+      # This indicates that program received SIGABRT signal.
+      ABORT = SIGNAL_BASE + 6 # 134
+
+      # This indicates that program received SIGKILL signal.
+      KILL = SIGNAL_BASE + 9 # 137
+
+      # This indicates that program received SIGBUS signal.
+      # Access to an undefined portion of a memory object
+      BUS_ERROR = SIGNAL_BASE + 10 # 138
+
+      # This indicates that program received SIGSEGV signal.
+      MEMORY_ERROR = SIGNAL_BASE + 11 # 139
+
+      # This indicates that program received SIGPIPE signal.
+      PIPE = SIGNAL_BASE + 13 # 141
+
+      # This indicates that program received SIGALARM signal.
+      ALARM = SIGNAL_BASE + 14 # 142
+
+      # This indicates that program received SIGUSR1 signal.
+      USER1 = SIGNAL_BASE + 30 # 158
+
+      # This indicates that program received SIGUSR2 signal.
+      USER2 = SIGNAL_BASE + 31 # 159
+    end # Code
+  end # Exit
+end # TTY

data/lib/tty/exit/registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TTY
+  module Exit
+    module Registry
+      # A storage for custom exit codes
+      #
+      # @api private
+      def self.exits
+        @exits ||= {}
+      end
+
+      # Register a custom exit code
+      #
+      # @param [String] name
+      # @param [Integer] code
+      # @param [String] message
+      #
+      # @api public
+      def self.register_exit(name, code, message)
+        exits[name] = {code: code, message: message}
+        exits[code] = {code: code, message: message}
+      end
+    end # Registry
+  end # Exit
+end # TTY

data/lib/tty/exit/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TTY
+  module Exit
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: tty-exit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Murach
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-01 00:00:00.000000000 Z
+dependencies: []
+description: Terminal exit codes for humans and machines
+email:
+- piotr@piotrmurach.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/tty-exit.rb
+- lib/tty/exit.rb
+- lib/tty/exit/code.rb
+- lib/tty/exit/registry.rb
+- lib/tty/exit/version.rb
+homepage: https://ttytoolkit.org
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/piotrmurach/tty-exit/issues
+  changelog_uri: https://github.com/piotrmurach/tty-exit/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/tty-exit
+  homepage_uri: https://ttytoolkit.org
+  source_code_uri: https://github.com/piotrmurach/tty-exit
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Terminal exit codes for humans and machines
+test_files: []