rexe 0.9.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aee272d801d5f73d5d742857baa103d108b366d2c4b82a64595d662dc47a438
-  data.tar.gz: ef605e5e1b9918215602abf481a20d1d24847c8fa36fc93ff9f91bcaf826547b
+  metadata.gz: 2c0055b60141171c65564e56db902aeb407184a8dae5abc89a1957238b3b35eb
+  data.tar.gz: 801efa318ca3a7dc8eeaea81e44d0f96331428465789c0cf9899196d6501c934
 SHA512:
-  metadata.gz: 86ac1e3509c6ff78fc4037c25b441b62786f3cf473aa3409678ec1adcce0c1e23def881137a20972ea5bf2ab605364986e80c83b6d4bdab5c8845d203d3fce07
-  data.tar.gz: 1fd4c1d947117fa60ab722bf5a16aae4a378ee31d36d95503cfa15abe15e158d3350e7dbf010b86b22515eeb9492a0b9f72c0099cd8950fca0015438fae4c8ad
+  metadata.gz: 1a87be47727dd851c36f93af89034f86ad7e268caa888a44018da344a6b1f9752f5e4e2bbf7460699f84b51bc47b2faf4b66cc6bac4f7b4f3b444856475cffd5
+  data.tar.gz: 9cdc86c7a7547e84c20286f6185162365453d5a3f0d556e98bc3b28dd6a2338b62999f722222394d4e749269535549cd22c1fa53ec68082fe0943377e8a6afb9

data/CHANGELOG.md

@@ -1,6 +1,21 @@
 ## rexe -- Ruby Command Line Executor
 
 
+### v0.10.1
+
+* Fix help text for input formats.
+
+
+### v0.10.0
+
+* Add input format option -i to simplify ingesting JSON, YAML, Marshal formats.
+* Add Marshal output option.
+* In -mn mode:
+  * change output behavior; now outputs last evaluated value like other modes.
+  * self is now a newly created object (Object.new), providing a clean slate for adding instance variables, methods, etc.
+* Wrap execution in Bundler.with_clean_env to enable loading of gems not in Gemfile.
+
+
 ### v0.9.0
 
 * Change -ms (single or separate string) mode to -ml (line) mode.

data/README.md

@@ -47,7 +47,7 @@ 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.9.0 -- https://github.com/keithrbennett/rexe
+rexe -- Ruby Command Line Executor/Filter -- v0.10.1 -- https://github.com/keithrbennett/rexe
 
 Executes Ruby code on the command line, optionally taking standard input and writing to standard output.
 
@@ -55,13 +55,27 @@ Options:
 
 -c  --clear_options        Clear all previous command line options specified up to now
 -h, --help                 Print help and exit
+-i, --input_format FORMAT  Input format (none is default)
+                             -ij  JSON
+                             -im  Marshal
+                             -in  None
+                             -iy  YAML
 -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated, or ! to clear
--m, --mode MODE            Mode with which to handle input (i.e. what `self` will be in your code):
-                           -ml line mode; each line is ingested as a separate string
-                           -me enumerator mode
-                           -mb big string mode; all lines combined into single multiline string
-                           -mn (default) no input mode; no special handling of input; self is not input 
+-m, --input_mode MODE      Mode with which to handle input (i.e. what `self` will be in your code):
+                             -ml  line mode; each line is ingested as a separate string
+                             -me  enumerator mode
+                             -mb  big string mode; all lines combined into single multiline string
+                             -mn  (default) no input mode; no special handling of input; self is not input 
 -n, --[no-]noop            Do not execute the code (useful with -v); see note (1) below
+-o, --output_format FORMAT Output format (puts is default):
+                             -oi  Inspect
+                             -oj  JSON
+                             -oJ  Pretty JSON
+                             -om  Marshal
+                             -on  No Output
+                             -op  Puts (default)
+                             -os  to_s
+                             -oy  YAML
 -r, --require REQUIRES     Gems and built-in libraries to require, comma separated, or ! to clear
 -v, --[no-]verbose         verbose mode (logs to stderr); see note (1) below
 
@@ -224,10 +238,11 @@ do so by using any of the following: `--[no-]verbose`, `-v n`, or `-v false`.
 
 ### Input Modes
 
-`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:
+`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, --mode MODE            Mode with which to handle input (i.e. what `self` will be in your code):
+-m, --input_mode MODE      Mode with which to handle input (i.e. what `self` will be in your code):
                            -ml line mode; each line is ingested as a separate string
                            -me enumerator mode
                            -mb big string mode; all lines combined into single multiline string
@@ -256,6 +271,10 @@ eybdoog
 `reverse` is implicitly called on each line of standard input.  `self`
  is the input line in each call (we could also have used `self.reverse` but the `self` would have been redundant.).
   
+Be aware that 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 might be better off using Enumerator
+mode and calling `select`, `filter`, `reject`, etc.
+
 
 #### -me "Enumerator" Filter Mode
 
@@ -304,9 +323,35 @@ input, you would have to code it yourself (e.g. as we did earlier with `STDIN.re
 If you may have more input than would fit in memory, you can do the following:
 
 * use `-ml` (line) mode so you are fed only 1 line at a time
-* use `-me` (enumerator) mode or use `-mn` (no input) mode with something like `STDIN.each_line`, 
-but make sure not to call any methods (e.g. `map`, `select`)
- that will produce an array of all the input
+* use an Enumerator, either by specifying the `-me` (enumerator) mode option,
+ or using `-mn` (no input) mode in conjunction with something like `STDIN.each_line`. Then: 
+** Make sure not to call any methods (e.g. `map`, `select`)
+ that will produce an array of all the input because that will pull all the records into memory, or:
+** use lazy enumerators
+ 
+
+
+### Output Formats
+
+Several output formats are provided for your convenience. Here they are in alphabetical order:
+
+* `-oa` (Awesome 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
+* `-on` (No Output) - output is suppressed
+* `-op` (Puts) - produces what `puts` would output
+* `-os` (To String) - calls `to_s` on the object
+* `-oy` (YAML) - calls `to_yaml` on the object
+
+All formats will implicitly `require` anything needed to accomplish their task (e.g. `require 'yaml'`).
+
+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.
+* It's much simpler to use multiple formats, as there is no need to change the code itself. This also enables
+parameterization of the output format.
 
 
 ### Implementing Domain Specific Languages (DSL's)
@@ -347,49 +392,7 @@ Ruby is supremely well suited for DSL's since it does not require parentheses fo
 so calls to your custom methods _look_ like built in language commands and keywords. 
 
 
-#### Suppressing Automatic Output in Filter Modes
-
-The filter input modes will automatically call `puts` to output the last evaulated value of your code to stdout. There may be times you may want to do something _else_ with the input and send nothing to stdout. For example, you might want to write something to a file, send to a network, etc. The simplest way to suppress output is to make nil or the empty string the final value in the expression. This can be accomplished simply merely by appending `; nil` or `;''` to your code. For example, to only output directory entries containing the letter 'e' in `-ml` (line) mode:
-
-```
-# Output only entries that contain the letter 'e':
-➜  /   ls | sort | rexe -ml "include?('e') ? self : nil"
-
-Incompatible Software
-
-Network
-...
-```
-
-However, as you can see, blank lines were displayed where `nil` was output. Why? Because in -ml mode,
- puts will be called unconditionally on whatever value is the result of the expression. In the case of nil,
- puts outputs an empty string and its usual newline. This is probably not what you want.
-
-If you want to see the `nil`s, you could replace `nil` with `nil.inspect`, which returns the string `'nil'`,
- unlike `nil.to_s` which returns the empty string. Of course, 
- there may be some other custom string you would want, 
- such as `[no match]` or `-`, or you could just specify the string `'nil'`. [^2]
-
-But you probably don't want any line at all to display for excluded objects. For this it is best to use 
-`-me` (enumerator) mode. If you won't have a huge amount of input data you could use `select`:
-
-```
-# Output only entries that contain the letter 'e':
-➜  /   ls | sort | rexe -me "select { |s| s.include?('e') }"
-Incompatible Software
-Network
-System
-```
-
-Here, `select` returns an array which is implicitly passed to `puts`. `puts` does _not_ call `to_s` when passed an array, but instead has special handling for arrays which prints each element on its own line. If instead we appended `.to_s` 
-or `.inspect` to the result array, we would get the more compact array notation: 
- 
-```
-➜  /   ls | sort | rexe -me "select { |s| s.include?('e') }.to_s"
-["Incompatible Software\n", "Network\n", ..., "private\n"]
-```
-
-#### Quoting Strings in Your Ruby Code
+### Quoting Strings in Your Ruby Code
 
 One complication of using utilities like `rexe` where Ruby code is specified on the shell command line is that
 you need to be careful about the shell's special treatment of certain characters. For this reason, it is often
@@ -399,12 +402,12 @@ An excellent reference for how they differ is [here](https://stackoverflow.com/q
 Feel free to fall back on Ruby's super useful `%q{}` and `%Q{}`, equivalent to single and double quotes, respectively.
 
 
-#### Mimicking Method Arguments
+### Mimicking Method Arguments
 
 You may want to support arguments in your code. One of the previous examples downloaded currency conversion rates. Let's find out the available currency codes:
 
 ```
-➜  /   echo $JSON_TEXT | rexe -rjson -mb \
+➜  /   echo $EUR_RATES_JSON | rexe -rjson -mb \
         "JSON.parse(self)['rates'].keys.sort.join(' ')"
 AUD BGN BRL CAD CHF CNY CZK DKK GBP HKD HRK HUF IDR ILS INR ISK JPY KRW MXN MYR NOK NZD PHP PLN RON RUB SEK SGD THB TRY USD ZAR
 ```
@@ -422,6 +425,35 @@ AUD BGN BRL CAD CHF CNY CZK DKK GBP HKD HRK HUF IDR ILS INR ISK JPY KRW MXN MYR
 In this code, `self` is the currency code `PHP` (Philippine Peso). We have accessed the JSON text to parse from the environment variable we previously populated.
 
 
+### Using the Clipboard for Text Processing
+
+Sometimes when editing text I need to do some one off text manipulation.
+Using the system's commands for pasting to and copying from the clipboard,
+this can easily be done. On the Mac, the `pbpaste` command outputs to stdout
+the clipboard content, and the `pbcopy` command copies its stdin to the clipboard.
+
+Let's say I have the following currency codes displayed on the screen:
+
+```
+AUD BGN BRL CAD CHF CNY CZK DKK GBP HKD HRK HUF IDR ILS INR ISK JPY KRW MXN MYR NOK NZD PHP PLN RON RUB SEK SGD THB TRY USD ZAR
+```
+
+...and I want to turn them into Ruby symbols for inclusion in Ruby source code as keys in a hash
+whose values will be the display names of the currencies, e.g "Australian Dollar").
+After copying this line to the clipboard, I could run this:
+
+```
+➜  ~   pbpaste | rexe -ml "split.map(&:downcase).map { |s| %Q{    #{s}: '',} }.join(%Q{\n})"
+    aud: '',
+    bgn: '',
+    brl: '',
+    # ...
+```
+
+If I add `| pbcopy` to the rexe command, then that output text would be copied into the clipboard instead of
+displayed in the terminal, and I could then paste it in my editor.
+
+
 ### More Examples
 
 Here are some more examples to illustrate the use of `rexe`.
@@ -529,7 +561,78 @@ straightforward to follow. Here's what it does:
 * use C-style printf formatting to align the text into two columns
 
  
+----
+
+Let's go a little crazy with the YouTube example.
+Let's have the video that loads be different for the success or failure
+of the command.
+
+If I put this in a load file (such as ~/.rexerc):
+
+```
+def play(piece_code)
+  pieces = {
+    hallelujah: "https://www.youtube.com/watch?v=IUZEtVbJT5c&t=0m20s",
+    rick_roll:  "https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=0m43s",
+    valkyries:  "http://www.youtube.com/watch?v=P73Z6291Pt8&t=0m28s",
+    wm_tell:    "https://www.youtube.com/watch?v=j3T8-aeOrbg",
+  }
+  `open #{Shellwords.escape(pieces.fetch(piece_code))}`
+end
+
+
+def play_result(success)
+  play(success ? :hallelujah : :rick_roll)
+end
+
 
+def play_result_by_exit_code
+  play_result(STDIN.read.chomp == '0')
+end
+
+```
+
+Then when I issue a command that succeeds, the Hallelujah Chorus is played:
+
+```
+➜  ~   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":
+
+```
+➜  ~   uuuuu; echo $? | rexe play_result_by_exit_code
+```
+
+----
+
+Another formatting example...I wanted to reformat this help text:
+
+```
+                                 'i' => Inspect
+                                 'j' => JSON
+                                 'J' => Pretty JSON
+                                 'n' => No Output
+                                 'p' => Puts (default)
+                                 's' => to_s
+                                 'y' => YAML
+```
+
+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:
+
+```
+➜  ~   pbpaste | rexe -ml "sub(%q{'}, '-o').sub(%q{' =>}, %q{ })"
+                                 -oi  Inspect
+                                 -oj  JSON
+                                 -oJ  Pretty JSON
+                                 -on  No Output
+                                 -op  Puts (default)
+                                 -os  to_s
+                                 -oy  YAML
+```                                 
+                                 
 
 
 ### Conclusion

data/exe/rexe

@@ -4,12 +4,13 @@
 #
 # Inspired by https://github.com/thisredone/rb
 
+require 'bundler'
 require 'optparse'
 require 'shellwords'
 
-class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
+class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :requires, :verbose, :noop)
 
-  VERSION = '0.9.0'
+  VERSION = '0.10.1'
 
   def initialize
     clear_options
@@ -19,10 +20,12 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
   # Used as an initializer and also when `-!` is specified on the command line.
   def clear_options
     self.input_mode = :no_input
+    self.output_format = :puts
     self.loads = []
     self.requires = []
     self.verbose = false
     self.noop = false
+    @output_formatter = nil
   end
 
 
@@ -37,13 +40,27 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
 
     -c  --clear_options        Clear all previous command line options specified up to now
     -h, --help                 Print help and exit
+    -i, --input_format FORMAT  Input format (none is default)
+                                 -ij  JSON
+                                 -im  Marshal
+                                 -in  None
+                                 -iy  YAML
     -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated, or ! to clear
-    -m, --mode MODE            Mode with which to handle input (i.e. what `self` will be in your code):
-                               -ml line mode; each line is ingested as a separate string
-                               -me enumerator mode
-                               -mb big string mode; all lines combined into single multiline string
-                               -mn (default) no input mode; no special handling of input; self is not input 
+    -m, --input_mode MODE      Mode with which to handle input (i.e. what `self` will be in your code):
+                                 -ml  line mode; each line is ingested as a separate string
+                                 -me  enumerator mode
+                                 -mb  big string mode; all lines combined into single multiline string
+                                 -mn  (default) no input mode; no special handling of input; self is not input 
     -n, --[no-]noop            Do not execute the code (useful with -v); see note (1) below
+    -o, --output_format FORMAT Output format (puts is default):
+                                 -oi  Inspect
+                                 -oj  JSON
+                                 -oJ  Pretty JSON
+                                 -om  Marshal
+                                 -on  No Output
+                                 -op  Puts (default)
+                                 -os  to_s
+                                 -oy  YAML
     -r, --require REQUIRES     Gems and built-in libraries to require, comma separated, or ! to clear
     -v, --[no-]verbose         verbose mode (logs to stderr); see note (1) below
 
@@ -80,6 +97,23 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
         exit
       end
 
+      parser.on('-i', '--input_format FORMAT',
+                'Mode with which to parse input values (n = none (default), j = JSON, m = Marshal, y = YAML') do |v|
+
+        modes = {
+            'j' => :json,
+            'm' => :marshal,
+            'n' => :none,
+            'y' => :yaml,
+        }
+
+        self.input_format = modes[v]
+        if self.input_format.nil?
+          puts help_text
+          raise "Input mode must be one of #{modes.keys}."
+        end
+      end
+
       parser.on('-l', '--load RUBY_FILE(S)', 'Ruby file(s) to load, comma separated, or ! to clear') do |v|
         if v == '!'
           self.loads.clear
@@ -93,7 +127,7 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
         end
       end
 
-      parser.on('-m', '--mode MODE',
+      parser.on('-m', '--input_mode MODE',
                 'Mode with which to handle input (-ml, -me, -mb, -mn (default)') do |v|
 
         modes = {
@@ -110,6 +144,28 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
         end
       end
 
+      parser.on('-o', '--output_format FORMAT',
+                'Mode with which to format values for output (`-o` + [aijJmnpsy])') do |v|
+
+        modes = {
+            'a' => :awesome_print,
+            'i' => :inspect,
+            'j' => :json,
+            'J' => :pretty_json,
+            'm' => :marshal,
+            'n' => :no_output,
+            'p' => :puts,         # default
+            's' => :to_s,
+            'y' => :yaml,
+        }
+
+        self.output_format = modes[v]
+        if self.output_format.nil?
+          puts help_text
+          raise "Output mode must be one of #{modes.keys}."
+        end
+      end
+
       parser.on('-r', '--require REQUIRE(S)',
                 'Gems and built-in libraries (e.g. shellwords, yaml) to require, comma separated, or ! to clear') do |v|
         if v == '!'
@@ -143,6 +199,7 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
 
     requires.uniq!
     loads.uniq!
+
   end
 
 
@@ -158,10 +215,13 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
 
 
   def execute(eval_context_object, code)
-    if eval_context_object
-      puts eval_context_object.instance_eval(&code)
-    else
-      code.call
+    unless input_format == :none
+      eval_context_object = input_parser.(eval_context_object)
+    end
+
+    value = eval_context_object.instance_eval(&code)
+    unless output_format == :no_output
+      print output_formatter.(value)
     end
   rescue Errno::EPIPE
     exit(-13)
@@ -195,7 +255,7 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
         line:           -> { STDIN.each { |l| execute(l.chomp, code) } },
         enumerator:     -> { execute(STDIN.each_line, code) },
         one_big_string: -> { big_string = STDIN.read; execute(big_string, code) },
-        no_input:       -> { execute(nil, code) }
+        no_input:       -> { execute(Object.new, code) }
     }
 
     if self.noop
@@ -209,7 +269,58 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose, :noop)
   end
 end
 
+
+def input_parser
+  if @input_parser.nil?
+
+    require 'json' if input_format == :json
+    require 'yaml' if input_format == :yaml
+
+    parsers = {
+        json:  ->(obj)   { JSON.parse(obj) },
+        marshal: ->(obj) { Marshal.load(obj) },
+        none:  ->(_obj)  { obj },
+        yaml:  ->(obj)   { YAML.load(obj) },
+    }
+
+    @input_parser = parsers[input_format]
+  end
+  @input_parser
+end
+
+
+def output_formatter
+  if @output_formatter.nil?
+
+    if %i(json  pretty_json).include?(output_format)
+      require 'json'
+    elsif output_format == :yaml
+      require 'yaml'
+    elsif output_format == :awesome_print
+      require 'awesome_print'
+    end
+
+    formatters = {
+        awesome_print: ->(obj)  { obj.ai },
+        inspect:       ->(obj)  { obj.inspect + "\n" },
+        json:          ->(obj)  { obj.to_json },
+        marshal:       ->(obj)  { Marshal.dump(obj) },
+        no_output:     ->(_obj) { nil },
+        pretty_json:   ->(obj)  { JSON.pretty_generate(obj) },
+        puts:          ->(obj)  { sio = StringIO.new; sio.puts(obj); sio.string },   # default
+        to_s:          ->(obj)  { obj.to_s + "\n" },
+        yaml:          ->(obj)  { obj.to_yaml },
+    }
+
+    @output_formatter = formatters[output_format]
+  end
+  @output_formatter
+end
+
+
 # This is needed because the gemspec file loads this file to access Rexe::VERSION
 # and must not have it run at that time:
 called_as_script = (File.basename($0) == File.basename(__FILE__))
-Rexe.new.call if called_as_script
+if called_as_script
+  Bundler.with_clean_env { Rexe.new.call }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rexe
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler