rexe 1.0.3 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76e23653efa666a3b5ebf1b991614dd9b98bed082d54cda2f660e1991a62d7d8
-  data.tar.gz: d01960aa820c05b2a933f0cee0fa78f894afd43ae275da31b5efad96ae5ee89e
+  metadata.gz: b7477c149efa64d0b00e4127d5219546c7ef1559fb7708ca8b389a9ef48c7348
+  data.tar.gz: 76114118d28be5a81561f8c67af9727fca5201a5ca443d0cdc6d60f5431451a1
 SHA512:
-  metadata.gz: b5c57cc8ff200ae90c8d6d143b444f0c0b58ad91a93dc7027be280b5c0396b01da2a67f67f475db7108924b117f53e0d6f7ac3583502846a8c5941edeba6693f
-  data.tar.gz: 1e6227b7c651668a7ca306c3bb70fba18a80fd8c6018a3db9fdca2185b94f988fcf289898fa432b33af118261a6dcb9ca426c5cdb29ab31e2bb878929785edbd
+  metadata.gz: 615ff910e6a79cdc38b574503253871e5141bf027f6753aaa2375a4b8e2a4108f2ebdd6eb4532dbd46daf655212ac8f6583b538f103164abcc1264e84ae71450
+  data.tar.gz: 6cd017a263416d521de4c1a8b55cdba5fb55605a053d3bb39e019c1521f19c1549eeed715cc9c8c37e90dbe7109681a27de56ee8ef6e53ffa41c337ebd2fb29a

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 ## rexe -- Ruby Command Line Executor/Filter
 
+### 1.5.0
+
+* Switch from AwesomePrint to AmazingPrint, and change all references in text, help, etc.
+
+
+### 1.4.1
+
+* As of later versions of Ruby, `stringio` is a gem and must be required. Fixed.
+
+
+### 1.4.0
+
+* Handle Bundler deprecation of `with_clean_env` method.
+* Mark entire file frozen_string_literal: true.
+
+
+### 1.3.1
+
+* Add Awesome Print and Pretty Print output formats to help.
+
+
+### 1.3.0
+
+* Document --project-url option.
+* Add undocumented option --open-project to output Github project URL.
+* Simplify test as per @davetron5000's array based approach.
+* Fix context do/end in test code.
+* Froze strings: VERSION, PROJECT_URL, help_text.
+
+
+### 1.2.0
+
+* Add --project-url option to output project URL on Github, then exit
+
+
+### 1.1.0
+
+* Enable specifying different output formats for tty and block devices. (#4)
+* Outputs exception text on error instead of just exception class.
+
 
 ### 1.0.3
 

data/README.md

@@ -2,7 +2,7 @@
 
 __Rexe__ is a Ruby script and gem that multiplies Ruby's usefulness and conciseness on the command line by:
 
-* automating parsing and formatting using JSON, YAML, Ruby marshalling, Awesome Print, and others
+* automating parsing and formatting using JSON, YAML, Ruby marshalling, Amazing Print, and others
 * simplifying the use of Ruby as a shell filter, optionally predigesting input as lines, an enumerator, or one big string
 * extracting the plumbing from the command line; requires and other options can be set in an environment variable
 * enabling the loading of Ruby helper files to keep your code DRY and your command line code high level
@@ -24,8 +24,8 @@ Sometimes a good solution is to combine Ruby and shell scripting on the same com
 Let's start by seeing what the Ruby interpreter already provides. Here we use `ruby` on the command line, using an intermediate environment variable to simplify the logic and save the data for use by future commands. An excerpt of the output follows the code:
 
 ```bash
-➜  ~   export EUR_RATES_JSON=`curl https://api.exchangeratesapi.io/latest`
-➜  ~   echo $EUR_RATES_JSON | ruby -r json -r yaml -e 'puts JSON.parse(STDIN.read).to_yaml'
+$ export EUR_RATES_JSON=`curl https://api.exchangeratesapi.io/latest`
+$ echo $EUR_RATES_JSON | ruby -r json -r yaml -e 'puts JSON.parse(STDIN.read).to_yaml'
 ```
 ```yaml
 ---
@@ -45,13 +45,13 @@ Unfortunately, the configuration setup (the `require`s) along with the reading,
 Rexe [see footnote ^1 regarding its origin] can simplify such commands. Among other things, rexe provides switch-activated input parsing and output formatting so that converting from one format to another is trivial. The previous `ruby` command can be expressed in `rexe` as:
 
 ```bash
-➜  ~   echo $EUR_RATES_JSON | rexe -mb -ij -oy self
+$ echo $EUR_RATES_JSON | rexe -mb -ij -oy self
 ```
 
 Or, even more concisely (`self` is the default Ruby source code for rexe commands):
 
 ```bash
-➜  ~   echo $EUR_RATES_JSON | rexe -mb -ij -oy
+$ echo $EUR_RATES_JSON | rexe -mb -ij -oy
 ```
 
 The command options may seem cryptic, but they're logical so it shouldn't take long to learn them:
@@ -63,7 +63,7 @@ The command options may seem cryptic, but they're logical so it shouldn't take l
 If input comes from a JSON or YAML file, rexe determines the input format from the file's extension, and it's even simpler:
 
 ```bash
-➜  ~   rexe -f eur_rates.json -oy
+$ rexe -f eur_rates.json -oy
 ```
 
 Rexe is at https://github.com/keithrbennett/rexe and can be installed with `gem install rexe`. Rexe provides several ways to simplify Ruby on the command line, tipping the scale so that it is practical to do it more often.
@@ -73,7 +73,7 @@ Rexe is at https://github.com/keithrbennett/rexe and can be installed with `gem
 Here is rexe's help text as of the time of this writing:
 
 ```
-rexe -- Ruby Command Line Executor/Filter -- v1.0.3 -- https://github.com/keithrbennett/rexe
+rexe -- Ruby Command Line Executor/Filter -- v1.5.0 -- https://github.com/keithrbennett/rexe
 
 Executes Ruby code on the command line, 
 optionally automating management of standard input and standard output,
@@ -107,14 +107,18 @@ Options:
 -n, --[no-]noop            Do not execute the code (useful with -g);
                            For true: yes, true, y, +; for false: no, false, n
 -o, --output_format FORMAT Output format, defaults to -on (no output):
+                             -oa  Amazing Print
                              -oi  Inspect
                              -oj  JSON
                              -oJ  Pretty JSON
                              -om  Marshal
                              -on  No Output (default)
                              -op  Puts
+                             -oP  Pretty Print
                              -os  to_s
                              -oy  YAML
+                             If 2 letters are provided, 1st is for tty devices, 2nd for block
+--project-url              Outputs project URL on Github, then exits
 -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated;
                              ! to clear all, or precede a name with '-' to remove
 -v, --version              Prints version and exits
@@ -131,7 +135,7 @@ before processing the input.
 
 If there is a REXE_OPTIONS environment variable, its content will be prepended
 to the command line so that you can specify options implicitly 
-(e.g. `export REXE_OPTIONS="-r awesome_print,yaml"`)
+(e.g. `export REXE_OPTIONS="-r amazing_print,yaml"`)
 ```
 
 ### Simplifying the Rexe Invocation
@@ -150,15 +154,15 @@ The `REXE_OPTIONS` environment variable can contain command line options that wo
 Instead of this:
 
 ```bash
-➜  ~   rexe -r wifi-wand -oa WifiWand::MacOsModel.new.wifi_info
+$ rexe -r wifi-wand -oa WifiWand::MacOsModel.new.wifi_info
 ```
 
 you can do this:
 
 ```bash
-➜  ~   export REXE_OPTIONS="-r wifi-wand -oa"
-➜  ~   rexe WifiWand::MacOsModel.new.wifi_info
-➜  ~   # [more rexe commands with the same options]
+$ export REXE_OPTIONS="-r wifi-wand -oa"
+$ rexe WifiWand::MacOsModel.new.wifi_info
+$ # [more rexe commands with the same options]
 ```
 
 Putting configuration options in `REXE_OPTIONS` effectively creates custom defaults, and is useful when you use the same options in most or all of your commands. Any options specified on the rexe command line will override the environment variable options.
@@ -185,7 +189,7 @@ To digress a bit, why would you want this? You might want to be able to go to an
 Here is an example of how you might use the `valkyries` method, assuming the above configuration is loaded from your `~/.rexerc` file or an explicitly loaded file:
 
 ```bash
-➜  ~   tar czf /tmp/my-whole-user-space.tar.gz ~ ; rexe valkyries
+$ tar czf /tmp/my-whole-user-space.tar.gz ~ ; rexe valkyries
 ```
 
 (Note that `;` is used rather than `&&` because we want to hear the music whether or not the command succeeds.)
@@ -209,7 +213,7 @@ end
 ...which you could then call like this:
 
 ```bash
-➜  ~   tar czf /tmp/my-whole-user-space.tar.gz ~ ; rexe 'play(:hallelujah)'
+$ tar czf /tmp/my-whole-user-space.tar.gz ~ ; rexe 'play(:hallelujah)'
 ```
 
 (You need to quote the `play` call because otherwise the shell will process and remove the parentheses. Alternatively you could escape the parentheses with backslashes.)
@@ -222,27 +226,29 @@ One of the examples at the end of this articles shows how you could have differe
 A log entry is optionally output to standard error after completion of the code. This entry is a hash representation (to be precise, `to_h`) of the `$RC` OpenStruct described in the $RC section below. It contains the version, date/time of execution, source code to be evaluated, options (after parsing both the `REXE_OPTIONS` environment variable and the command line), and the execution time of your Ruby code:
  
 ```bash
-➜  ~   echo $EUR_RATES_JSON | rexe -gy -ij -mb -oa -n self
+$ echo $EUR_RATES_JSON | rexe -gy -ij -mb -oa -n self
 ```
 ```yaml
 ---
 :count: 0
-:rexe_version: 1.0.0
-:start_time: '2019-04-15T13:12:15+08:00'
+:rexe_version: 1.3.1
+:start_time: '2019-09-11T13:28:46+07:00'
 :source_code: self
 :options:
   :input_filespec:
   :input_format: :json
   :input_mode: :one_big_string
   :loads: []
-  :output_format: :awesome_print
+  :output_format: :amazing_print
+  :output_format_tty: :amazing_print
+  :output_format_block: :amazing_print
   :requires:
-  - awesome_print
+  - amazing_print
   - json
   - yaml
   :log_format: :yaml
   :noop: true
-:duration_secs: 0.050326
+:duration_secs: 0.095705
 ```
 
 We specified `-gy` for YAML format; there are other formats as well (see the help output or this document) and the default is `-gn`, which means don't output the log entry at all.
@@ -254,7 +260,7 @@ This extra output is sent to standard error (_stderr_) instead of standard outpu
 If you would like to append this informational output to a file(e.g. `rexe.log`), you could do something like this:
 
 ```bash
-➜  ~   rexe ... -gy 2>>rexe.log
+$ rexe ... -gy 2>>rexe.log
 ```
 
 
@@ -263,12 +269,13 @@ If you would like to append this informational output to a file(e.g. `rexe.log`)
 Rexe tries to make it simple and convenient for you to handle standard input, and in different ways. Here is the help text relating to input modes:
 
 ```
--m, --input_mode MODE      Input preprocessing mode (determines what `self` will be):
+-m, --input_mode MODE      Input preprocessing mode (determines what `self` will be)
+                           defaults to -mn (none)
                              -ml  line; each line is ingested as a separate string
                              -me  enumerator (each_line on STDIN or File)
                              -mb  big string; all lines combined into one string
-                             -mn  none (default); no input preprocessing; 
-                                  self is an Object.new 
+                             -mn  none (default); no input preprocessing;
+                                  self is an Object.new
 ```
 
 The first three are _filter_ modes; they make standard input available to your code as `self`.
@@ -281,7 +288,7 @@ The last (and default) is the _executor_ mode. It merely assists you in executin
 In this mode, your code would be called once per line of input, and in each call, `self` would evaluate to each line of text:
 
 ```bash
-➜  ~   echo "hello\ngoodbye" | rexe -ml puts reverse
+$ echo "hello\ngoodbye" | rexe -ml puts reverse
 olleh
 eybdoog
 ```
@@ -303,7 +310,7 @@ Dealing with input as an enumerator enables you to use the wealth of `Enumerable
 Here is an example of using `-me` to add line numbers to the first 3 files in the directory listing:
 
 ```bash
-➜  ~   ls / | rexe -me "first(3).each_with_index { |ln,i| puts '%5d  %s' % [i, ln] }"
+$ ls / | rexe -me "first(3).each_with_index { |ln,i| puts '%5d  %s' % [i, ln] }"
 
     0  AndroidStudioProjects
     1  Applications
@@ -356,7 +363,7 @@ The input format option is ignored if the input _mode_ is `-mn` ("no input" exec
 
 Several output formats are provided for your convenience:
 
-* `-oa` - Awesome Print - calls `.ai` on the object to get the string that `ap` would print
+* `-oa` - Amazing Print - calls `.ai` on the object to get the string that `ap` would print
 * `-oi` - Inspect - calls `inspect` on the object
 * `-oj` - JSON - calls `to_json` on the object
 * `-oJ` - Pretty JSON calls `JSON.pretty_generate` with the object
@@ -369,6 +376,8 @@ All formats will implicitly `require` anything needed to accomplish their task (
 
 The default is `-on` to produce no output at all (unless explicitly coded to do so). If you prefer a different default such as `-op` for _puts_ mode, you can specify that in your `REXE_OPTIONS` environment variable.
 
+If two letters are provided, the first will be used for tty devices (e.g. the terminal when not redirected or piped), and the second for block devices (e.g. when redirected or piped to another process).
+
 You may wonder why these formats are provided, given that their functionality could be included in the custom code instead. Here's why:
 
 * The savings in command line length goes a long way to making these commands more readable and feasible.
@@ -381,12 +390,12 @@ You may wonder why these formats are provided, given that their functionality co
 Rexe also simplifies getting input from a file rather than standard input. The `-f` option takes a filespec and does with its content exactly what it would have done with standard input. This shortens:
 
 ```bash
-➜  ~   cat filename.ext | rexe ...
+$ cat filename.ext | rexe ...
 ```
 ...to...
 
 ```bash
-➜  ~   rexe -f filename.ext ...
+$ rexe -f filename.ext ...
 ```
 
 This becomes even more useful if you are using files whose extensions are `.yml`, `.yaml`, or `.json` (case insensitively). In this case the input format and mode will be set automatically for you to:
@@ -397,14 +406,14 @@ This becomes even more useful if you are using files whose extensions are `.yml`
 So the example we gave above:
 
 ```bash
-➜  ~   export EUR_RATES_JSON=`curl https://api.exchangeratesapi.io/latest`
-➜  ~   echo $EUR_RATES_JSON | rexe -mb -ij -oy self
+$ export EUR_RATES_JSON=`curl https://api.exchangeratesapi.io/latest`
+$ echo $EUR_RATES_JSON | rexe -mb -ij -oy self
 ```
 ...could be changed to:
 
 ```bash
-➜  ~   curl https://api.exchangeratesapi.io/latest > eur_rates.json
-➜  ~   rexe -f eur_rates.json -oy self
+$ curl https://api.exchangeratesapi.io/latest > eur_rates.json
+$ rexe -f eur_rates.json -oy self
 ``` 
 
 Another possible win for using `-f` is that since it is a command line option, it could be specified in `REXE_OPTIONS`. This could be useful if you are doing many operations on the same file.
@@ -412,7 +421,7 @@ Another possible win for using `-f` is that since it is a command line option, i
 If you need to override the input mode and format automatically configured for file input, you can simply specify the desired options on the command line _after_ the `-f`:
 
 ```bash
-➜  ~   rexe -f eur_rates.json -mb -in 'puts self.class, self[0..20]'
+$ rexe -f eur_rates.json -mb -in 'puts self.class, self[0..20]'
 String
 {"base":"EUR","rates"
 ```
@@ -443,21 +452,23 @@ This feature is probably only useful in the filter modes, since in the executor
 For your convenience, the information displayed in verbose mode is available to your code at runtime by accessing the `$RC` global variable, which contains an OpenStruct. Let's print out its contents using YAML:
  
 ```bash
-➜  ~   rexe -oy '$RC'
+$ rexe -oy '$RC'
 ```
 ```yaml
 --- !ruby/object:OpenStruct
 table:
   :count: 0
-  :rexe_version: 1.0.0
-  :start_time: '2019-04-15T13:25:56+08:00'
+  :rexe_version: 1.3.1
+  :start_time: '2019-09-11T13:25:53+07:00'
   :source_code: "$RC"
   :options:
-    :input_filespec:
+    :input_filespec: 
     :input_format: :none
     :input_mode: :none
     :loads: []
     :output_format: :yaml
+    :output_format_tty: :yaml
+    :output_format_block: :yaml
     :requires:
     - yaml
     :log_format: :none
@@ -468,7 +479,7 @@ modifiable: true
 Probably most useful in that object at runtime is the record count, accessible with both `$RC.count` and `$RC.i`. This is only really useful in line mode, because in the others it will always be 0 or 1. Here is an example of how you might use it as a kind of progress indicator:
 
 ```bash
-➜  ~   find / | rexe -ml -on \
+$ find / | rexe -ml -on \
 'if $RC.i % 1000 == 0; puts %Q{File entry ##{$RC.i} is #{self}}; end'
 ```
 ```
@@ -487,22 +498,22 @@ Note that a single quote was used for the Ruby code here; if a double quote were
 Defining methods in your loaded files enables you to effectively define a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) for your command line use. You could use different load files for different projects, domains, or contexts, and define aliases or one line scripts to give them meaningful names. For example, if you had Ansible helper code in `~/projects/ansible-tools/rexe-ansible.rb`, you could define an alias in your startup script:
 
 ```bash
-➜  ~   alias rxans="rexe -l ~/projects/ansible-tools/rexe-ansible.rb $*"
+$ alias rxans="rexe -l ~/projects/ansible-tools/rexe-ansible.rb $*"
 ```
 ...and then you would have an Ansible DSL available for me to use by calling `rxans`.
 
 In addition, since you can also call `pry` on the context of any object, you can provide a DSL in a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) (shell) trivially easily. Just to illustrate, here's how you would open a REPL on the File class:
 
 ```bash
-➜  ~   ruby -r pry -e File.pry
+$ ruby -r pry -e File.pry
 # or
-➜  ~   rexe -r pry File.pry
+$ rexe -r pry File.pry
 ```
 
 `self` would evaluate to the `File` class, so you could call class methods using only their names:
 
 ```bash
-➜  ~   rexe -r pry File.pry
+$ rexe -r pry File.pry
 ```
 ```
 [6] pry(File)> size '/etc/passwd'
@@ -516,7 +527,7 @@ true
 This could be really handy if you call `pry` on a custom object that has methods especially suited to your task:
 
 ```bash
-➜  ~   rexe -r wifi-wand,pry  WifiWand::MacOsModel.new.pry
+$ rexe -r wifi-wand,pry  WifiWand::MacOsModel.new.pry
 ```
 ```
 [1] pry(#<WifiWand::MacOsModel>)> random_mac_address
@@ -537,25 +548,25 @@ Personally, I find single quotes more useful since I usually don't want special
 Sometimes it doesn't matter:
 
 ```bash
-➜  ~   rexe 'puts "hello"'
+$ rexe 'puts "hello"'
 hello
-➜  ~   rexe "puts 'hello'"
+$ rexe "puts 'hello'"
 hello
 ```
 
 We can also use `%q` or `%Q`, and sometimes this eliminates the needs for the outer quotes altogether:
 
 ```bash
-➜  ~   rexe puts %q{hello}
+$ rexe puts %q{hello}
 hello
-➜  ~   rexe puts %Q{hello}
+$ rexe puts %Q{hello}
 hello
 ```
 
 Sometimes the quotes to use on the outside (quoting your command in the shell) need to be chosen based on which quotes are needed on the inside. For example, in the following command, we need double quotes in Ruby in order for interpolation to work, so we use single quotes on the outside:
 
 ```bash
-➜  ~   rexe puts '"The time is now #{Time.now}"'
+$ rexe puts '"The time is now #{Time.now}"'
 ```
 ```
 The time is now 2019-03-29 16:41:26 +0800
@@ -564,7 +575,7 @@ The time is now 2019-03-29 16:41:26 +0800
 In this case we also need to use single quotes on the outside, because we need literal double quotes in a `%Q{}` expression:
 
 ```bash
-➜  ~   rexe 'puts %Q{The operating system name is "#{`uname`.chomp}".}'
+$ rexe 'puts %Q{The operating system name is "#{`uname`.chomp}".}'
 ```
 ```
 The operating system name is "Darwin".
@@ -573,7 +584,7 @@ The operating system name is "Darwin".
 We can eliminate the need for any quotes in the Ruby code using `%Q{}`:
 
 ```bash
-➜  ~   rexe puts '%Q{The time is now #{Time.now}}'
+$ rexe puts '%Q{The time is now #{Time.now}}'
 ```
 ```
 The time is now 2019-03-29 17:06:13 +0800
@@ -604,7 +615,7 @@ AUD BGN BRL CAD CHF CNY CZK DKK GBP HKD HRK HUF IDR ILS INR ISK JPY KRW MXN MYR
 The codes output are the legal arguments that could be sent to rexe's stdin as an argument in the command below. Let's find out the Euro exchange rate for _PHP_, Philippine Pesos:
  
 ```bash
-➜  ~   echo PHP | rexe -ml -op -rjson \
+$ echo PHP | rexe -ml -op -rjson \
         "rate = JSON.parse(ENV['EUR_RATES_JSON'])['rates'][self];\
         %Q{1 EUR = #{rate} #{self}}"
 
@@ -636,13 +647,13 @@ AUD BGN BRL PHP TRY USD ZAR
 We could manually select that text and use system menu commands or keys to copy it to the clipboard, or we could do this:
 
 ```bash
-➜  ~   echo AUD BGN BRL PHP TRY USD ZAR | pbcopy
+$ echo AUD BGN BRL PHP TRY USD ZAR | pbcopy
 ```
 
 After copying this line to the clipboard, we could run this:
 
 ```bash
-➜  ~   pbpaste | rexe -ml -op \
+$ pbpaste | rexe -ml -op \
         "split.map(&:downcase).map { |s| %Q{    #{s}: '',} }.join(%Q{\n})"
     aud: '',
     bgn: '',
@@ -661,7 +672,7 @@ Although rexe is cleanest with short one liners, you may want to use it to inclu
 What might not be so obvious is that you will often need to use semicolons as statement separators. For example, here is an example without a semicolon:
 
 ```bash
-➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m} \
+$ cowsay hello | rexe -me "print %Q{\u001b[33m} \
 puts to_a"
 ```
 ```
@@ -673,13 +684,13 @@ rexe: (eval):1: syntax error, unexpected tIDENTIFIER, expecting '}'
 The shell combines all backslash terminated lines into a single line of text, so when the Ruby interpreter sees your code, it's all in a single line:
 
 ```bash
-➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m} puts to_a"
+$ cowsay hello | rexe -me "print %Q{\u001b[33m} puts to_a"
 ```
 
 Adding the semicolon fixes the problem:
 
 ```bash
-➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m}; \
+$ cowsay hello | rexe -me "print %Q{\u001b[33m}; \
 puts to_a"
 ```
 ```
@@ -703,7 +714,7 @@ There may be times when you have specified a load or require on the command line
 2) Unspecify individual requires or loads by preceding the name with `-`, e.g. `-r -rails`. Array subtraction is used, and array subtraction removes _all_ occurrences of each element of the subtracted (subtrahend) array, so:
 
 ```bash
-➜  ~   rexe -n -r rails,rails,rails,-rails -gP
+$ rexe -n -r rails,rails,rails,-rails -gP
 ...
    :requires=>["pp"],
 ...
@@ -714,7 +725,7 @@ There may be times when you have specified a load or require on the command line
 We could have also extracted the requires list programmatically using `$RC` (described above) by doing this:
 
 ```bash
-➜  ~   rexe -oP -r rails,rails,rails,-rails '$RC[:options][:requires]'
+$ rexe -oP -r rails,rails,rails,-rails '$RC[:options][:requires]'
 ["pp"]
 ```    
 
@@ -729,9 +740,9 @@ You can also clear _all_ options specified up to a certain point in time with th
 For consistency with the `ruby` interpreter, rexe supports requires with the `-r` option, but also allows grouping them together using commas:
 
 ```bash
-                                    vvvvvvvvvvvvvvvvvvvvv
-➜  ~   echo $EUR_RATES_JSON | rexe -r json,awesome_print 'ap JSON.parse(STDIN.read)'
-                                    ^^^^^^^^^^^^^^^^^^^^^
+                                 vvvvvvvvvvvvvvvvvv
+$ echo $EUR_RATES_JSON | rexe -r json,amazing_print 'ap JSON.parse(STDIN.read)'
+                                 ^^^^^^^^^^^^^^^^^^
 ```
 
 Files loaded with the `-l` option are treated the same way.
@@ -742,9 +753,9 @@ Files loaded with the `-l` option are treated the same way.
 Requiring gems and modules for _all_ invocations of rexe will make your commands simpler and more concise, but will be a waste of execution time if they are not needed. You can inspect the execution times to see just how much time is being consumed. For example, we can find out that rails takes about 0.63 seconds to load on one system by observing and comparing the execution times with and without the require (output has been abbreviated using `grep`):
 
 ```bash
-➜  ~   rexe -gy -r rails 2>&1 | grep duration
+$ rexe -gy -r rails 2>&1 | grep duration
 :duration_secs: 0.660138
-➜  ~   rexe -gy          2>&1 | grep duration
+$ rexe -gy          2>&1 | grep duration
 :duration_secs: 0.027781
 ```
 (For the above to work, the `rails` gem and its dependencies need to be installed.)
@@ -766,29 +777,29 @@ Here are some more examples to illustrate the use of rexe.
 To output the result to stdout, you can either call `puts` or specify the `-op` option:
 
 ```bash
-➜  ~   rexe puts 1 / 3.0
+$ rexe puts 1 / 3.0
 0.3333333333333333
 ```
 
 or:
 
 ```bash
-➜  ~   rexe -op 1 / 3.0
+$ rexe -op 1 / 3.0
 0.3333333333333333
 ```
 
 Since `*` is interpreted by the shell, if we do multiplication, we need to quote the expression:
 
 ```bash
-➜  ~   rexe -op '2 * 7'
+$ rexe -op '2 * 7'
 14
 ```
 
 Of course, if you put the `-op` in the `REXE_OPTIONS` environment variable, you don't need to be explicit about the output:
 
 ```bash
-➜  ~   export REXE_OPTIONS=-op
-➜  ~   rexe '2 * 7'
+$ export REXE_OPTIONS=-op
+$ rexe '2 * 7'
 14
 ```
 
@@ -797,10 +808,10 @@ Of course, if you put the `-op` in the `REXE_OPTIONS` environment variable, you
 
 #### Outputting ENV
 
-Output the contents of `ENV` using AwesomePrint [see footnote ^4 regarding ENV.to_s]:
+Output the contents of `ENV` using AmazingPrint [see footnote ^4 regarding ENV.to_s]:
 
 ```bash
-➜  ~   rexe -oa ENV
+$ rexe -oa ENV
 ```
 ```
 {
@@ -819,7 +830,7 @@ Output the contents of `ENV` using AwesomePrint [see footnote ^4 regarding ENV.t
 Show disk space used/free on a Mac's main hard drive's main partition:
 
 ```bash
-➜  ~   df -h | grep disk1s1 | rexe -ml \
+$ df -h | grep disk1s1 | rexe -ml \
 "x = split; puts %Q{#{x[4]} Used: #{x[2]}, Avail: #{x[3]}}"
 91% Used: 412Gi, Avail: 44Gi
 ```
@@ -833,7 +844,7 @@ Show disk space used/free on a Mac's main hard drive's main partition:
 Show the 3 longest file names of the current directory, with their lengths, in descending order:
 
 ```bash
-➜  ~   ls  | rexe -ml -op "%Q{[%4d] %s} % [length, self]" | sort -r | head -3
+$ ls  | rexe -ml -op "%Q{[%4d] %s} % [length, self]" | sort -r | head -3
 [  50] Agoda_Booking_ID_9999999 49_–_RECEIPT_enclosed.pdf
 [  40] 679a5c034994544aab4635ecbd50ab73-big.jpg
 [  28] 2018-abc-2019-01-16-2340.zip
@@ -848,11 +859,11 @@ When you right align numbers using printf formatting, sorting the lines alphabet
 This uses an [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code) to output text to the terminal in yellow:
 
 ```bash
-➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m}; puts to_a"
-➜  ~     # or
-➜  ~   cowsay hello | rexe -mb "print %Q{\u001b[33m}; puts self"
-➜  ~     # or
-➜  ~   cowsay hello | rexe "print %Q{\u001b[33m}; puts STDIN.read"
+$ cowsay hello | rexe -me "print %Q{\u001b[33m}; puts to_a"
+$   # or
+$ cowsay hello | rexe -mb "print %Q{\u001b[33m}; puts self"
+$   # or
+$ cowsay hello | rexe "print %Q{\u001b[33m}; puts STDIN.read"
 ```
 ```
   _______
@@ -901,13 +912,13 @@ end
 Then when we issue a command that succeeds, the Hallelujah Chorus is played [see footnote ^2]:
 
 ```bash
-➜  ~   uname; echo $? | rexe play_result_by_exit_code
+$ uname; echo $? | rexe play_result_by_exit_code
 ```
 
 ...but when the command fails, in this case, with an executable which is not found, it plays Rick Astley's "Never Gonna Give You Up":
 
 ```bash
-➜  ~   uuuuu; echo $? | rexe play_result_by_exit_code
+$ uuuuu; echo $? | rexe play_result_by_exit_code
 ```
 
 ----
@@ -929,7 +940,7 @@ Another formatting example...I wanted to reformat this source code...
 ...into something more suitable for my help text. Admittedly, the time it took to do this with rexe probably exceeded the time to do it manually, but it was an interesting exercise and made it easy to try different formats. Here it is, after copying the original text to the clipboard:
 
 ```bash
-➜  ~   pbpaste | rexe -ml -op "sub(%q{'}, '-o').sub(%q{' =>}, %q{ })"
+$ pbpaste | rexe -ml -op "sub(%q{'}, '-o').sub(%q{' =>}, %q{ })"
          -oi  Inspect
          -oj  JSON
          -oJ  Pretty JSON
@@ -986,7 +997,7 @@ lib/rock_books/documents/journal_entry.rb:
 So this is what worked well for me:
 
 ```bash
-➜  ~   grep Struct **/*.rb | grep -v OpenStruct | rexe -ml -op \
+$ grep Struct **/*.rb | grep -v OpenStruct | rexe -ml -op \
 "a =                            \
  gsub('lib/rock_books/', '')    \
 .gsub('< Struct.new',    '')    \

data/exe/rexe

@@ -4,6 +4,9 @@
 #
 # Inspired by https://github.com/thisredone/rb
 
+# frozen_string_literal: true
+
+
 require 'bundler'
 require 'date'
 require 'optparse'
@@ -12,7 +15,7 @@ require 'shellwords'
 
 class Rexe
 
-  VERSION = '1.0.3'
+  VERSION = '1.5.0'
 
   PROJECT_URL = 'https://github.com/keithrbennett/rexe'
 
@@ -25,7 +28,7 @@ class Rexe
         yield
       rescue Exception => e
         unless e.class == SystemExit
-          $stderr.puts('rexe: ' << e.class.to_s)
+          $stderr.puts("rexe: #{e}")
           $stderr.puts("Use the -h option to get help.")
           exit(-1)
         end
@@ -40,6 +43,8 @@ class Rexe
       :input_mode,
       :loads,
       :output_format,
+      :output_format_tty,
+      :output_format_block,
       :requires,
       :log_format,
       :noop)
@@ -53,13 +58,15 @@ class Rexe
 
     def clear
       self.input_filespec = nil
-      self.input_format   = :none
-      self.input_mode     = :none
-      self.output_format  = :none
-      self.loads          = []
-      self.requires       = []
-      self.log_format     = :none
-      self.noop           = false
+      self.input_format        = :none
+      self.input_mode          = :none
+      self.output_format       = :none
+      self.output_format_tty   = :none
+      self.output_format_block = :none
+      self.loads               = []
+      self.requires            = []
+      self.log_format          = :none
+      self.noop                = false
     end
   end
 
@@ -100,7 +107,7 @@ class Rexe
 
     def output_formats
       @output_formats ||= {
-          'a' => :awesome_print,
+          'a' => :amazing_print,
           'i' => :inspect,
           'j' => :json,
           'J' => :pretty_json,
@@ -116,14 +123,14 @@ class Rexe
 
     def formatters
       @formatters ||=  {
-          awesome_print: ->(obj)  { obj.ai << "\n" },
+          amazing_print: ->(obj)  { obj.ai << "\n" },
           inspect:       ->(obj)  { obj.inspect + "\n" },
           json:          ->(obj)  { obj.to_json },
           marshal:       ->(obj)  { Marshal.dump(obj) },
           none:          ->(_obj) { nil },
           pretty_json:   ->(obj)  { JSON.pretty_generate(obj) },
           pretty_print:  ->(obj)  { obj.pretty_inspect },
-          puts:          ->(obj)  { sio = StringIO.new; sio.puts(obj); sio.string },   # default
+          puts:          ->(obj)  { require 'stringio'; sio = StringIO.new; sio.puts(obj); sio.string },
           to_s:          ->(obj)  { obj.to_s + "\n" },
           yaml:          ->(obj)  { obj.to_yaml },
       }
@@ -134,7 +141,7 @@ class Rexe
       @format_requires ||= {
           json:          'json',
           pretty_json:   'json',
-          awesome_print: 'awesome_print',
+          amazing_print: 'amazing_print',
           pretty_print:  'pp',
           yaml:          'yaml'
       }
@@ -173,69 +180,79 @@ class Rexe
 
 
     private def help_text
-      <<~HEREDOC
-
-    rexe -- Ruby Command Line Executor/Filter -- v#{VERSION} -- #{PROJECT_URL}
-
-    Executes Ruby code on the command line, 
-    optionally automating management of standard input and standard output,
-    and optionally parsing input and formatting output with YAML, JSON, etc.
-
-    rexe [options] [Ruby source code]
-
-    Options:
-
-    -c  --clear_options        Clear all previous command line options specified up to now
-    -f  --input_file           Use this file instead of stdin for preprocessed input; 
-                               if filespec has a YAML and JSON file extension,
-                               sets input format accordingly and sets input mode to -mb
-    -g  --log_format FORMAT    Log format, logs to stderr, defaults to -gn (none)
-                               (see -o for format options)
-    -h, --help                 Print help and exit
-    -i, --input_format FORMAT  Input format, defaults to -in (None)
-                                 -ij  JSON
-                                 -im  Marshal
-                                 -in  None (default)
-                                 -iy  YAML
-    -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated;
-                                 ! to clear all, or precede a name with '-' to remove
-    -m, --input_mode MODE      Input preprocessing mode (determines what `self` will be)
-                               defaults to -mn (none)
-                                 -ml  line; each line is ingested as a separate string
-                                 -me  enumerator (each_line on STDIN or File)
-                                 -mb  big string; all lines combined into one string
-                                 -mn  none (default); no input preprocessing; 
-                                      self is an Object.new 
-    -n, --[no-]noop            Do not execute the code (useful with -g);
-                               For true: yes, true, y, +; for false: no, false, n
-    -o, --output_format FORMAT Output format, defaults to -on (no output):
-                                 -oi  Inspect
-                                 -oj  JSON
-                                 -oJ  Pretty JSON
-                                 -om  Marshal
-                                 -on  No Output (default)
-                                 -op  Puts
-                                 -os  to_s
-                                 -oy  YAML
-    -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated;
-                                 ! to clear all, or precede a name with '-' to remove
-    -v, --version              Prints version and exits
-
-    ---------------------------------------------------------------------------------------
-                                                                                                
-    In many cases you will need to enclose your source code in single or double quotes.
-
-    If source code is not specified, it will default to 'self', 
-    which is most likely useful only in a filter mode (-ml, -me, -mb).
-
-    If there is a .rexerc file in your home directory, it will be run as Ruby code 
-    before processing the input.
-
-    If there is a REXE_OPTIONS environment variable, its content will be prepended
-    to the command line so that you can specify options implicitly 
-    (e.g. `export REXE_OPTIONS="-r awesome_print,yaml"`)
+      unless @help_text
+        @help_text ||= <<~HEREDOC
+
+          rexe -- Ruby Command Line Executor/Filter -- v#{VERSION} -- #{PROJECT_URL}
+      
+          Executes Ruby code on the command line, 
+          optionally automating management of standard input and standard output,
+          and optionally parsing input and formatting output with YAML, JSON, etc.
+      
+          rexe [options] [Ruby source code]
+      
+          Options:
+      
+          -c  --clear_options        Clear all previous command line options specified up to now
+          -f  --input_file           Use this file instead of stdin for preprocessed input; 
+                                     if filespec has a YAML and JSON file extension,
+                                     sets input format accordingly and sets input mode to -mb
+          -g  --log_format FORMAT    Log format, logs to stderr, defaults to -gn (none)
+                                     (see -o for format options)
+          -h, --help                 Print help and exit
+          -i, --input_format FORMAT  Input format, defaults to -in (None)
+                                       -ij  JSON
+                                       -im  Marshal
+                                       -in  None (default)
+                                       -iy  YAML
+          -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated;
+                                       ! to clear all, or precede a name with '-' to remove
+          -m, --input_mode MODE      Input preprocessing mode (determines what `self` will be)
+                                     defaults to -mn (none)
+                                       -ml  line; each line is ingested as a separate string
+                                       -me  enumerator (each_line on STDIN or File)
+                                       -mb  big string; all lines combined into one string
+                                       -mn  none (default); no input preprocessing; 
+                                            self is an Object.new 
+          -n, --[no-]noop            Do not execute the code (useful with -g);
+                                     For true: yes, true, y, +; for false: no, false, n
+          -o, --output_format FORMAT Output format, defaults to -on (no output):
+                                       -oa  Amazing Print
+                                       -oi  Inspect
+                                       -oj  JSON
+                                       -oJ  Pretty JSON
+                                       -om  Marshal
+                                       -on  No Output (default)
+                                       -op  Puts
+                                       -oP  Pretty Print
+                                       -os  to_s
+                                       -oy  YAML
+                                       If 2 letters are provided, 1st is for tty devices, 2nd for block
+          --project-url              Outputs project URL on Github, then exits
+          -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated;
+                                       ! to clear all, or precede a name with '-' to remove
+          -v, --version              Prints version and exits
+      
+          ---------------------------------------------------------------------------------------
+                                                                                                      
+          In many cases you will need to enclose your source code in single or double quotes.
+      
+          If source code is not specified, it will default to 'self', 
+          which is most likely useful only in a filter mode (-ml, -me, -mb).
+      
+          If there is a .rexerc file in your home directory, it will be run as Ruby code 
+          before processing the input.
+      
+          If there is a REXE_OPTIONS environment variable, its content will be prepended
+          to the command line so that you can specify options implicitly 
+          (e.g. `export REXE_OPTIONS="-r amazing_print,yaml"`)
 
       HEREDOC
+
+        @help_text.freeze
+      end
+
+      @help_text
     end
 
 
@@ -348,10 +365,11 @@ class Rexe
 
         parser.on('-o', '--output_format FORMAT',
                   'Mode with which to format values for output (`-o` + [aijJmnpsy])') do |v|
-
-          options.output_format = lookups.output_formats[v]
-          if options.output_format.nil?
-            raise("Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}.")
+          options.output_format_tty   = lookups.output_formats[v[0]]
+          options.output_format_block = lookups.output_formats[v[-1]]
+          options.output_format = ($stdout.tty? ? options.output_format_tty : options.output_format_block)
+          if [options.output_format_tty, options.output_format_block].include?(nil)
+            raise("Bad output mode '#{v}'; each must be one of #{lookups.output_formats.keys}.")
           end
         end
 
@@ -375,12 +393,17 @@ class Rexe
           exit(0)
         end
 
-        # Undocumented feature
+        # Undocumented feature: open Github project with default web browser on a Mac
         parser.on('', '--open-project') do
           open_resource(PROJECT_URL)
           exit(0)
         end
 
+        parser.on('', '--project-url') do
+          puts PROJECT_URL
+          exit(0)
+        end
+
       end.parse!
 
       # We want to do this after all options have been processed because we don't want any clearing of the
@@ -528,4 +551,19 @@ class Rexe
   end
 end
 
-Bundler.with_clean_env { Rexe::Main.new.call }
+
+def bundler_run(&block)
+  # This used to be an unconditional call to with_clean_env but that method is now deprecated:
+  # [DEPRECATED] `Bundler.with_clean_env` has been deprecated in favor of `Bundler.with_unbundled_env`.
+  # If you instead want the environment before bundler was originally loaded,
+  # use `Bundler.with_original_env`
+
+  if Bundler.respond_to?(:with_unbundled_env)
+    Bundler.with_unbundled_env { block.call }
+  else
+    Bundler.with_clean_env { block.call }
+  end
+end
+
+
+bundler_run { Rexe::Main.new.call }

data/rexe.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "awesome_print"
+  spec.add_dependency "amazing_print"
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "os"

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rexe
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.5.0
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2020-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: amazing_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -125,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Ruby Command Line Executor