rexe 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38c1bab41a36c75950db8a2a8aa05f46d324f3c221b66181cc8df302b97aabe7
-  data.tar.gz: 6a3e33b62857804eb18179233aa3de385ee7b44785dbb1fdd27de4a95e9aa0bc
+  metadata.gz: 982527b8b9d991102d3a3a1eb5ae83e7235cea0b77b782921ab6e203a5c70f42
+  data.tar.gz: a586d1f5c68beaf81692f23920e1c2e8c435e44e7095b38e90a70f4b113fa32c
 SHA512:
-  metadata.gz: 52d97220ae00afd76ecb7253f626c135be6f33622130cf43edcabb90bb63f93b8ee3e143734059a6f69a80d57800c29d47adc4c8569c7b08e54676853a6eb36a
-  data.tar.gz: ea666de41864df7f84315e69e4481fd1a1b79bf4c32da29b1e76a4483a4a3276a99e494ecf47850e124170ac43ba00cb5c8e10d81421620d3f2b27bbe5c3af21
+  metadata.gz: ffb97f15aae0ed61a2acabdfa2d330d15814d2c4ada682c1eae0099d8b5dd9262d1fa7e47142051d18ca5f5efddee2ef755efeb9b22d555bf2621327305e572c
+  data.tar.gz: ce5ae9551e7fad281a7505bb99c4749098eb9560fd377dc33ea3341ae29e5d4d490bfea807b426e36bf79f7cfbc597416da2cf50ab475343854908d49d131708

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 ## rexe -- Ruby Command Line Executor
 
 
+### 0.14.0
+
+* The default output format has been changed from -op (:puts) to -on (:none).
+* Support automatic input from file with -f option.
+* Normalize load filespecs to eliminate duplication and to facilitate correct deletion.
+
+
 ### v0.13.0
 
 * Much refactoring.

data/README.md

@@ -8,13 +8,13 @@ and the source code, and at minimum, reading the Conclusion.]_
 
 ----
 
-I love the power of the command line, but not the awkwardness of shell scripting
-languages. Sure, there's a lot that can be done with them, but it doesn't take
-long before I get frustrated with their bluntness and verbosity.
-
+Shell scripting is great for simple tasks but for anything nontrivial
+it can easily get cryptic and awkward (pun intended!).
+ 
 Often, I solve this problem by writing a Ruby script instead. Ruby gives me fine
-grained control in a "real" programming language with which I am comfortable.
-However, when there are multiple OS commands to be called, then Ruby can be
+grained control in a language that is all about clarity, conciseness, and expressiveness.
+
+Unfortunately, when there are multiple OS commands to be called, then Ruby can be
 awkward too.
 
 ### Using the Ruby Interpreter on the Command Line
@@ -50,6 +50,12 @@ The previous `ruby` command can be expressed in `rexe` as:
 ```
 ➜  ~   echo $EUR_RATES_JSON | rexe -mb -ij -oy self
 ```
+
+The command options may seem cryptic, but they're logical so it shouldn't take long to learn them:
+
+* `-mb` - __mode__ to consume all standard input as a single __big__ string
+* `-ij` - parse that __input__ with __JSON__; `self` will be the parsed object
+* `-oy` - __output__ the final value as __YAML__
  
 `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
@@ -60,21 +66,24 @@ line, tipping the scale so that it is practical to do it more often.
 Here is `rexe`'s help text as of the time of this writing:
 
 ```
-rexe -- Ruby Command Line Executor/Filter -- v0.13.0 -- https://github.com/keithrbennett/rexe
+rexe -- Ruby Command Line Executor/Filter -- v0.14.0 -- https://github.com/keithrbennett/rexe
 
-Executes Ruby code on the command line, optionally taking standard input and writing to standard output.
+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; autodetects YAML and JSON file extensions
+                           If YAML or JSON: parses file in that mode, sets input mode to -mb
 -g  --log_format FORMAT    Log format, logs to stderr, defaults to none (see -o for format options)
 -h, --help                 Print help and exit
--i, --input_format FORMAT  Input format (defaults to none)
+-i, --input_format FORMAT  Input format
                              -ij  JSON
                              -im  Marshal
-                             -in  None
+                             -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
@@ -90,8 +99,8 @@ Options:
                              -oj  JSON
                              -oJ  Pretty JSON
                              -om  Marshal
-                             -on  No Output
-                             -op  Puts (default)
+                             -on  No Output (default)
+                             -op  Puts
                              -os  to_s
                              -oy  YAML
 -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated;
@@ -118,11 +127,24 @@ There are two main ways we can make the `rexe` command line even more concise:
 The `REXE_OPTIONS` environment variable can contain command line options that would otherwise
 be specified on the `rexe` command line:
 
+Instead of this:
+
 ```
-➜  ~   export REXE_OPTIONS="-r json,awesome_print"
-➜  ~   echo $EUR_RATES_JSON | rexe 'ap JSON.parse(STDIN.read)'
+➜  ~   rexe -r wifi-wand -oa  WifiWand::MacOsModel.new.wifi_info
 ```
 
+you can do this:
+
+```
+➜  ~   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 options in most or all of your commands. Any options specified on the `rexe`
+command line will override the environment variable options.
+
 Like any environment variable, `REXE_OPTIONS` could also be set in your startup script, input on a command line using `export`, or in another script loaded with `source` or `.`.
 
 ### Loading Files
@@ -155,14 +177,14 @@ You might be thinking that creating an alias or a minimal shell script for this
 approach, and I would agree with you. However, over time the number of these could become unmanageable, whereas using Ruby
 you could build a pretty extensive and well organized library of functionality. Moreover, that functionality could be made available to _all_ your Ruby code (for example, by putting it in a gem), and not just command line one liners.
 
-For example, you could have something like this in a configuration file:
+For example, you could have something like this in a gem or loaded file:
 
 ```
 def play(piece_code)
   pieces = {
     hallelujah: "https://www.youtube.com/watch?v=IUZEtVbJT5c&t=0m20s",
     valkyries:  "http://www.youtube.com/watch?v=P73Z6291Pt8&t=0m28s",
-    wm_tell:    "https://www.youtube.com/watch?v=j3T8-aeOrbg"
+    wm_tell:    "https://www.youtube.com/watch?v=j3T8-aeOrbg&t=0m1s",
     # ... and many, many more
   }
   `open #{Shellwords.escape(pieces.fetch(piece_code))}`
@@ -178,6 +200,8 @@ end
 (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.)
 
+One of the examples at the end of this articles shows how you could have different music play for success and failure.
+
 
 ### Logging
 
@@ -187,12 +211,12 @@ to be evaluated, options (after parsing both the `REXE_OPTIONS` environment vari
 and the execution time of your Ruby code:
  
 ```
-➜  ~   echo $EUR_RATES_JSON | rexe -gy -rjson,awesome_print "ap JSON.parse(STDIN.read)"
+➜  ~   echo $EUR_RATES_JSON | rexe -gy -ij -oa self
 ...
 ---
 :count: 0
-:rexe_version: 0.12.0
-:start_time: '2019-03-19T19:39:18+08:00'
+:rexe_version: 0.13.0
+:start_time: '2019-03-21T20:58:51+08:00'
 :source_code: ap JSON.parse(STDIN.read)
 :options:
   :input_format: :none
@@ -200,25 +224,26 @@ and the execution time of your Ruby code:
   :loads: []
   :output_format: :puts
   :requires:
-  - json
   - awesome_print
+  - json
   - yaml
   :log_format: :yaml
   :noop: false
-:duration_secs: 0.116171
+:duration_secs: 0.070381
 ``` 
 
-The `yaml` require was not explicitly specified but is automatically added because
-`rexe` will add any requires needed for automatic parsing and formatting.
+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.
+
+The requires you see were not explicitly specified but were automatically added because
+`rexe` will add any requires needed for automatic parsing and formatting, and
+we specified those formats in the command line options `-gy -ij -oa`.
  
 This extra output is sent to standard error (_stderr_) instead of standard output
 (_stdout_) so that it will not pollute the "real" data when stdout is piped to
 another command.
 
-As you can see, the data is the YAML representation of a hash, so you could easily ingest it and
-use it programatically.
-
-If you would like to append this informational output to a file, you could do something like this:
+If you would like to append this informational output to a file(e.g. `rexe.log`), you could do something like this:
 
 ```
 ➜  ~   rexe ... -gy 2>>rexe.log
@@ -264,7 +289,7 @@ eybdoog
   
 Be aware that, in this mode, although you can control the _content_ of output records, 
 there is no way to selectively _exclude_ records from being output. Even if the result of the code
-is nil or the empty string, a newline will be output. If this is an issue, you could do one of the following:
+is nil or the empty string, a newline will be output. To prevent this, you can do one of the following:
  
  * use `-me` Enumerator mode and call `select`, `filter`, `reject`, etc.
  * use the `-on` _no output_ mode and call `puts` explicitly for the output you _do_ want
@@ -281,7 +306,7 @@ Here is an example of using `-me` to add line numbers to the first 3
 files in the directory listing:
 
 ```
-➜  ~   ls / | rexe -me "first(3).each_with_index { |ln,i| puts '%5d  %s' % [i, ln] }; nil"
+➜  ~   ls / | rexe -me -on "first(3).each_with_index { |ln,i| puts '%5d  %s' % [i, ln] }"
 
     0  AndroidStudioProjects
     1  Applications
@@ -289,6 +314,7 @@ files in the directory listing:
 ```
 
 Since `self` is an enumerable, we can call `first` and then `each_with_index`.
+The `-on` says don't do any automatic output, just the output explicitly specified by `puts` in the source code.
 
 
 #### -mb "Big String" Filter Mode
@@ -296,7 +322,7 @@ Since `self` is an enumerable, we can call `first` and then `each_with_index`.
 In this mode, all standard input is combined into a single (possibly
 large) string, with newline characters joining the lines in the string.
 
-A good example of when you would use this is when you parse JSON or YAML text; 
+A good example of when you would use this is when you need to parse a multiline JSON or YAML representation of an object; 
 you need to pass the entire (probably) multiline string to the parse method. 
 This is the mode that was used in the first `rexe` example in this article.
 
@@ -362,16 +388,75 @@ could be included in the custom code instead. Here's why:
 parameterization of the output format.
 
 
+### Reading Input from a File
+
+`rexe` also simplifies getting input from a file rather than standard input. The `-f` option takes a filespec
+and does with exactly what it would have done with standard input. This shortens:
+
+```
+➜  ~   cat filename.ext | rexe ...
+```
+...to...
+
+```
+➜  ~   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:
+
+* `-iy` (YAML) or `-ij` (JSON) depending on the file extension
+* `-mb` (one big string mode), which assumes that the most common use case will be to parse the entire file at once
+
+So the example we gave above:
+
+```
+➜  ~   export EUR_RATES_JSON=`curl https://api.exchangeratesapi.io/latest`
+➜  ~   echo $EUR_RATES_JSON | rexe -mb -ij -oy self
+```
+...could be changed to:
+
+```
+➜  ~   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.
+
 ### The $RC Global OpenStruct
 
 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. Probably most useful in that object
+by accessing the `$RC` global variable, which contains an OpenStruct. Let's print out its contents using AwesomePrint:
+ 
+```
+➜  ~   rexe -oa '$RC'
+OpenStruct {
+           :count => 0,
+    :rexe_version => "0.13.0",
+      :start_time => "2019-03-23T20:17:59+08:00",
+     :source_code => "$RC",
+         :options => {
+         :input_format => :none,
+           :input_mode => :no_input,
+                :loads => [],
+        :output_format => :awesome_print,
+             :requires => [
+            [0] "awesome_print"
+        ],
+           :log_format => :none,
+                 :noop => false
+    }
+}
+``` 
+ 
+Probably most useful in that object
 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:
 
 ```
-➜  ~   ➜  ~   find / | rexe -ml -on \
+➜  ~   find / | rexe -ml -on \
 'if $RC.i % 1000 == 0; puts %Q{File entry ##{$RC.i} is #{self}}; end'
 ...
 File entry #106000 is /usr/local/Cellar/go/1.11.5/libexec/src/cmd/vendor/github.com/google/pprof/internal/driver/driver_test.go
@@ -404,10 +489,10 @@ trivially easily. Just to illustrate, here's how you would open a REPL on the Fi
 ➜  ~   rexe -r pry File.pry
 ```
 
-`self` would evaluate to the `File` class, so you could call class methods implicitly using only their names:
+`self` would evaluate to the `File` class, so you could call class methods using only their names:
 
 ```
-➜  ~   rexe  -r pry File.pry
+➜  ~   rexe -r pry File.pry
 
 [6] pry(File)> size '/etc/passwd'
 6804
@@ -420,7 +505,7 @@ true
 This could be really handy if you call `pry` on a custom object that has methods especially suited to your task:
 
 ```
-➜  ~   rexe  -r  wifi-wand,pry  WifiWand::MacOsModel.new.pry
+➜  ~   rexe -r  wifi-wand,pry  WifiWand::MacOsModel.new.pry
 ```
 
 Ruby is supremely well suited for DSL's since it does not require parentheses for method calls, 
@@ -435,8 +520,7 @@ necessary to quote the Ruby code. You can use single or double quotes to have th
 as a single argument. 
 An excellent reference for how they differ is [here](https://stackoverflow.com/questions/6697753/difference-between-single-and-double-quotes-in-bash).
 
-Personally, I find single quotes more useful since special characters like `$` in my Ruby code will
-not be disturbed.
+Personally, I find single quotes more useful since I usually don't want special characters in my Ruby code  like `$` to be processed by the shell.
 
 When specifying the Ruby code, feel free to fall back on Ruby's super useful `%q{}` and `%Q{}`,
 equivalent to single and double quotes, respectively.
@@ -520,20 +604,7 @@ when you change the content of the clipboard.
 Although `rexe` is cleanest with short one liners, you may want to use it to include nontrivial Ruby code
 in your shell script as well. If you do this, you may need to add trailing backslashes to the lines of Ruby code.
 
-In addition, don't forget you can use `%q{}` and `%Q{}` in your Ruby code instead of single and double quotes.
-
-
-### The Use of Semicolons
-
-You will probably find yourself using semicolons much more often than usual when you use `rexe`.
-Obviously you would need them to separate statements on the same line:
-
-```
-➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m}; puts to_a"
-```
-
-What might not be so obvious is that you _also_ need them if each statement is on its own line.
-For example, here is an example without a semicolon:
+What might not be so obvious is that you will often need to use semicolons. For example, here is an example without a semicolon:
 
 ```
 ➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m} \
@@ -605,17 +676,15 @@ Files loaded with the `-l` option are treated the same way.
 
 ### Beware of Configured Requires
 
-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 wasted. For example, we can find out that nokogiri takes about 0.15 seconds to load on my laptop by observing and comparing the execution times with and without the require (output has been abbreviated using the redirection and grep):
+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 wasted. For example, we can find out that rails takes about 0.63 seconds to load on my laptop by observing and comparing the execution times with and without the require (output has been abbreviated using the redirection and grep):
 
 ```
-➜  ~    rexe -gy 2>&1 "''" | grep duration
-:duration_secs: 0.0012
-
-➜  ~   rexe -gy -r nokogiri "''" 2>&1 | grep duration
-:duration_secs: 0.148671
+➜  ~   rexe -gy -r rails 123 2>&1 | grep duration
+:duration_secs: 0.660138
+➜  ~   rexe -gy          123 2>&1 | grep duration
+:duration_secs: 0.027781
 ```
-
-(For the above to work, the `nokogiri` gem needs to be installed.)
+(For the above to work, the `rails` gem and its dependencies need to be installed.)
 
 
 ### Operating System Support
@@ -630,7 +699,33 @@ Windows non-Unix shells.
 Here are some more examples to illustrate the use of `rexe`.
 
 ----
-Output the contents of `ENV` using AwesomePrint:
+
+### Format Conversions -- JSON, YAML, AwesomePrint
+
+You may work with YAML or JSON a lot and need to inspect files from time to time.
+`rexe` makes it easy to convert from one format to another. For example, here's a
+command to convert from `countries.yaml` to AwesomePrint:
+
+```
+cat countries.yaml | rexe -iy -oa -mb self
+```
+
+You can easily create a script that automates this. Using your favorite editor,
+put this in a file:
+
+```
+cat $1 | rexe -iy -oa -mb self
+```
+
+I put mine in a file called `y2a` in my `~/bin` directory where I keep custom scripts like this.
+
+Now you can call `y2a` to output any YAML file using AwesomePrint.
+
+----
+
+#### Outputting ENV
+
+Output the contents of `ENV` using AwesomePrint [^3]:
 
 ```
 ➜  ~   rexe -oa ENV
@@ -645,6 +740,8 @@ Output the contents of `ENV` using AwesomePrint:
 
 ----
 
+#### Reformatting a Command's Output
+
 Show disk space used/free on a Mac's main hard drive's main partition:
 
 ```
@@ -657,7 +754,23 @@ Show disk space used/free on a Mac's main hard drive's main partition:
 
 ----
 
-Print yellow (trust me!):
+#### Formatting for Numeric Sort
+    
+Show the 3 longest file names of the current directory, with their lengths, in descending order:
+
+```
+➜  ~   ls  | rexe -ml "%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
+```
+
+When you right align numbers using printf formatting, sorting the lines
+alphabetically will result in sorting them numerically as well.
+
+----
+
+#### Print yellow (trust me!):
 
 ```
 ➜  ~   cowsay hello | rexe -me "print %Q{\u001b[33m}; puts to_a"
@@ -678,75 +791,9 @@ Print yellow (trust me!):
 
 ----
 
-    
-Show the 3 longest file names of the current directory, with their lengths, in descending order:
-
-```
-➜  ~   ls  | rexe -ml "%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
-```
-
-Notice that when you right align numbers using printf formatting, sorting the lines
-alphabetically will result in sorting them numerically as well.
-
 ----
 
-I was recently asked to provide a schema for the data in my `rock_books` accounting gem. `rock_books` data is intended to be very small in size, and no data base is used. Instead, the input data is parsed on every run, and reports generated on demand. However, there are data structures (actually class instances) in memory at runtime, and their classes inherit from `Struct`.
- The definition lines look like this one:
- 
-```
-class JournalEntry < Struct.new(:date, :acct_amounts, :doc_short_name, :description, :receipts)
-```
-
-The `grep` command line utility prepends each of these matches with a string like this:
-
-```
-lib/rock_books/documents/journal_entry.rb:
-```
-
-So this is what worked well for me:
-
-```
-➜  ~   grep Struct **/*.rb | grep -v OpenStruct | rexe -ml \
-"a = \
- gsub('lib/rock_books/', '')\
-.gsub('< Struct.new',    '')\
-.gsub('; end',           '')\
-.split('.rb:')\
-.map(&:strip);\
-\
-%q{%-40s %-s} % [a[0] + %q{.rb}, a[1]]"
-```
-
-...which produced this output:
-
-``` 
-cmd_line/command_line_interface.rb       class Command (:min_string, :max_string, :action)
-documents/book_set.rb                    class BookSet (:run_options, :chart_of_accounts, :journals)
-documents/journal.rb                     class Entry (:date, :amount, :acct_amounts, :description)
-documents/journal_entry.rb               class JournalEntry (:date, :acct_amounts, :doc_short_name, :description, :receipts)
-documents/journal_entry_builder.rb       class JournalEntryBuilder (:journal_entry_context)
-reports/report_context.rb                class ReportContext (:chart_of_accounts, :journals, :page_width)
-types/account.rb                         class Account (:code, :type, :name)
-types/account_type.rb                    class AccountType (:symbol, :singular_name, :plural_name)
-types/acct_amount.rb                     class AcctAmount (:date, :code, :amount, :journal_entry_context)
-types/journal_entry_context.rb           class JournalEntryContext (:journal, :linenum, :line)
-``` 
-
-Although there's a lot going on here, the vertical and horizontal alignments and spacing make the code
-straightforward to follow. Here's what it does:
-
-* grep the code base for `"Struct"`
-* exclude references to `"OpenStruct"` with `grep -v`
-* remove unwanted text with `gsub`
-* split the line into 1) a filespec relative to `lib/rockbooks`, and 2) the class definition
-* strip unwanted space because that will mess up the horizontal alignment of the output.
-* use C-style printf formatting to align the text into two columns
-
- 
-----
+#### More YouTube: Differentiating Success and Failure 
 
 Let's go a little crazy with the YouTube example.
 Let's have the video that loads be different for the success or failure
@@ -792,7 +839,9 @@ Then when I issue a command that succeeds, the Hallelujah Chorus is played:
 
 ----
 
-Another formatting example...I wanted to reformat this help text...
+#### Reformatting Source Code for Help Text
+
+Another formatting example...I wanted to reformat this source code...
 
 ```
                                  'i' => Inspect
@@ -820,7 +869,61 @@ but it was an interesting exercise and made it easy to try different formats. He
 ```                                 
                                  
 
+#### Reformatting Grep Output
 
+I was recently asked to provide a schema for the data in my `rock_books` accounting gem. `rock_books` data is intended to be very small in size, and no data base is used. Instead, the input data is parsed on every run, and reports generated on demand. However, there are data structures (actually class instances) in memory at runtime, and their classes inherit from `Struct`.
+ The definition lines look like this one:
+ 
+```
+class JournalEntry < Struct.new(:date, :acct_amounts, :doc_short_name, :description, :receipts)
+```
+
+The `grep` command line utility prepends each of these matches with a string like this:
+
+```
+lib/rock_books/documents/journal_entry.rb:
+```
+
+So this is what worked well for me:
+
+```
+➜  ~   grep Struct **/*.rb | grep -v OpenStruct | rexe -ml \
+"a = \
+ gsub('lib/rock_books/', '')\
+.gsub('< Struct.new',    '')\
+.gsub('; end',           '')\
+.split('.rb:')\
+.map(&:strip);\
+\
+%q{%-40s %-s} % [a[0] + %q{.rb}, a[1]]"
+```
+
+...which produced this output:
+
+``` 
+cmd_line/command_line_interface.rb       class Command (:min_string, :max_string, :action)
+documents/book_set.rb                    class BookSet (:run_options, :chart_of_accounts, :journals)
+documents/journal.rb                     class Entry (:date, :amount, :acct_amounts, :description)
+documents/journal_entry.rb               class JournalEntry (:date, :acct_amounts, :doc_short_name, :description, :receipts)
+documents/journal_entry_builder.rb       class JournalEntryBuilder (:journal_entry_context)
+reports/report_context.rb                class ReportContext (:chart_of_accounts, :journals, :page_width)
+types/account.rb                         class Account (:code, :type, :name)
+types/account_type.rb                    class AccountType (:symbol, :singular_name, :plural_name)
+types/acct_amount.rb                     class AcctAmount (:date, :code, :amount, :journal_entry_context)
+types/journal_entry_context.rb           class JournalEntryContext (:journal, :linenum, :line)
+``` 
+
+Although there's a lot going on here, the vertical and horizontal alignments and spacing make the code
+straightforward to follow. Here's what it does:
+
+* grep the code base for `"Struct"`
+* exclude references to `"OpenStruct"` with `grep -v`
+* remove unwanted text with `gsub`
+* split the line into 1) a filespec relative to `lib/rockbooks`, and 2) the class definition
+* strip unwanted space because that will mess up the horizontal alignment of the output.
+* use C-style printf formatting to align the text into two columns
+
+ 
 ### Conclusion
 
 `rexe` is not revolutionary technology, it's just plumbing that removes parsing,
@@ -873,3 +976,4 @@ Here is a _start_ at a method that opens a resource portably across operating sy
   end
 ```
 
+[^3]: It is an interesting quirk of the Ruby language that `ENV.to_s` returns `"ENV"` and not the contents of the `ENV` object. As a result, most of the other output formats will return some form of `"ENV"`. You can handle this by specifying `ENV.to_h`.