rexe 0.10.3 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 606431741970f4fde8a4d54e93c788af091f7422868b2f5975477a217767497c
-  data.tar.gz: 326d91170d3759fdb35f74eceb4bf308ff545ee8cebff1a8e22699de6e9f7a4b
+  metadata.gz: 148f8f91ef5ee20f245d74ee2b16b75550622b7ba80c139a671a26e2e383a482
+  data.tar.gz: 495447fbd26d0b8205d5c703e6c02577e5b9f85df11ec0892d4717689c17837e
 SHA512:
-  metadata.gz: 722be782787590850d8651fc2afb9040f617c26b376713e0aee52d73ddc5765c9d412cdb852542d5ef5705a8a0136738125a0d5ed4af2d3c080093345d82684f
-  data.tar.gz: e1a97fae20c9bdeb2db1db74e76c41342461689222225ee875fa02d6a4e2af0b78ab8208b3db4110f6ba68fc39e1e3b917fc62c9e41b46cc5ff24eee11792bae
+  metadata.gz: fae8f53b62e75773a1245ea5b7e411328146a8bb80538522ec344dd18a86df65523e3226e15421537865a1db7196352f2cd25004303e63b5d0af3fb944e52dcf
+  data.tar.gz: eacd19481d49bd663ce6d8a9033a73c6eec711031ac766593b60aeca28296c4dacfb38450893ab857bc005663bd29b95883d7a638d45e878d36b7dab7388d5b3

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 ## rexe -- Ruby Command Line Executor
 
 
+### v0.11.0
+
+* Make global $RC (Rexe Context) OpenStruct available to user code; added `count` for record count in `-ml` mode.
+* Change verbose output to YAML format.
+* Failure to load a file now raises an error.
+* Add pretty print output format.
+* Fix tests.
+
+
 ### v0.10.3
 
 * Fix: parsing should not be attempted if in no input mode.

data/README.md

@@ -56,10 +56,12 @@ This command does the same thing as the previous `ruby` command:
 `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.
 
+----
+
 Here is `rexe`'s help text as of the time of this writing:
 
 ```
-rexe -- Ruby Command Line Executor/Filter -- v0.10.3 -- https://github.com/keithrbennett/rexe
+rexe -- Ruby Command Line Executor/Filter -- v0.11.0 -- https://github.com/keithrbennett/rexe
 
 Executes Ruby code on the command line, optionally taking standard input and writing to standard output.
 
@@ -126,29 +128,9 @@ Like any environment variable, `REXE_OPTIONS` could also be set in your startup
 
 ### Loading Files
 
-The environment variable approach works well for command line _options_, but what if we want to specify Ruby _code_ (e.g. methods) that can be used by multiple invocations of `rexe`?
+The environment variable approach works well for command line _options_, but what if we want to specify Ruby _code_ (e.g. methods) that can be used by your `rexe` code?
 
-For this, `rexe` lets you _load_ Ruby files, using the `-l` option, or implicitly (without your specifying it) in the case of the `~/.rexerc` file. Here is an example of something you might include in such a file (this is an alternate approach to specifying `-r` in the `REXE_OPTIONS` environment variable):
-
-```
-require 'json'
-require 'yaml'
-require 'awesome_print'
-```
-
-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.7 seconds to load on my laptop by observing and comparing the execution times with and without the require (output has been abbreviated):
-
-```
-➜  ~   rexe -v
-rexe time elapsed: 0.094946 seconds.
-
-➜  ~   rexe -v -r nokogiri
-rexe time elapsed: 0.165996 seconds.
-```
-
-### Using Loaded Files in Your Commands
-
-Here's something else you could include in such a load file:
+For this, `rexe` lets you _load_ Ruby files, using the `-l` option, or implicitly (without your specifying it) in the case of the `~/.rexerc` file. Here is an example of something you might include in such a file:
 
 ```
 # Open YouTube to Wagner's "Ride of the Valkyries"
@@ -166,7 +148,9 @@ an explicitly loaded file:
 ➜  ~   tar czf /tmp/my-whole-user-space.tar.gz ~ ; rexe valkyries
 ```
 
-You might be thinking that creating an alias or a minimal shell script for this open would be a simpler and more natural
+(Note that `;` is used rather than `&&` because we want to hear the music whether or not the command succeeds.)
+
+You might be thinking that creating an alias or a minimal shell script for this `open` would be a simpler and more natural
 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.
 
@@ -194,41 +178,39 @@ end
 Alternatively you could escape the parentheses with backslashes.)
 
 
-### Clearing the Require and Load Lists
-
-There may be times when you have specified a load or require on the command line
-or in the `REXE_OPTIONS` environment variable,
-but you want to override it for a single invocation. Currently you cannot
-unspecify a single resource, but you can unspecify _all_ the requires or loads
-with the `-r!` and `-l!` command line options, respectively.
-
-
-### Clearing _All_ Options
-
-You can also clear _all_ options specified up to a certain point in time with the _clear options_ option (`-c`).
-This is especially useful if you have specified options in the `REXE_OPTIONS` environment variable, 
-and want to ignore all of them.
-
-
 ### Verbose Mode
 
-In addition to displaying the execution time, verbose mode will display the version, date/time of execution, source code
-to be evaluated, options specified (by all approaches), and that the global file has been loaded (if it was found):
+Verbose mode will display the version, date/time of execution, source code
+to be evaluated, options specified (by all approaches), that the global file has been loaded (if it was found),
+and the execution time of your Ruby code:
  
 ```
 ➜  ~   echo $EUR_RATES_JSON | rexe -v -rjson,awesome_print "ap JSON.parse(STDIN.read)"
-rexe version 0.7.0 -- 2019-03-03 18:18:14 +0700
-Source Code: ap JSON.parse(STDIN.read)
-Options: {:input_mode=>:no_input, :loads=>[], :requires=>["json", "awesome_print"], :verbose=>true}
-Loading global config file /Users/kbennett/.rexerc
-...
-rexe time elapsed: 0.085913 seconds.
+---
+:count: 0
+:rexe_version: 0.11.0
+:start_time: '2019-03-11T20:16:02+07:00'
+:source_code: ap JSON.parse(STDIN.read)
+:options:
+  :input_format: :none
+  :input_mode: :no_input
+  :loads: []
+  :output_format: :puts
+  :requires:
+  - json
+  - awesome_print
+  :verbose: true
+  :noop: false
+:duration_secs: 0.032174
 ``` 
  
 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:
 
 ```
@@ -373,6 +355,24 @@ could be included in the custom code instead. Here's why:
 parameterization of the output format.
 
 
+### 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
+is the record count (as `$RC.count`). 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:
+
+```
+➜  ~   ➜  ~   find / | rexe -ml -on \
+'n = $RC.count; if n % 1000 == 0; puts %Q{File entry ##{n} 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
+File entry #107000 is /usr/local/Cellar/go/1.11.5/libexec/src/go/types/testdata/cycles1.src
+File entry #108000 is /usr/local/Cellar/go/1.11.5/libexec/src/runtime/os_linux_novdso.go
+...
+```
+
 ### Implementing Domain Specific Languages (DSL's)
 
 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 I wrote code to work with Ansible and put it in `~/projects/rexe-ansible.rb`, I could define an alias in my startup script:
@@ -473,6 +473,10 @@ After copying this line to the clipboard, I could run this:
 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.
 
+Using the clipboard in manual operations is handy, but using it in automated scripts is a very bad idea, since
+there is only one clipboard per user session. If you use the clipboard in an automated script you risk
+an error situation if its content is changed by others, or, conversely, you could mess up another task
+when you change the content of the clipboard. 
 
 ### Multiline Ruby Commands
 
@@ -523,6 +527,22 @@ puts to_a"
 ```
 
 
+### Clearing the Require and Load Lists
+
+There may be times when you have specified a load or require on the command line
+or in the `REXE_OPTIONS` environment variable,
+but you want to override it for a single invocation. Currently you cannot
+unspecify a single resource, but you can unspecify _all_ the requires or loads
+with the `-r!` and `-l!` command line options, respectively.
+
+
+### Clearing _All_ Options
+
+You can also clear _all_ options specified up to a certain point in time with the _clear options_ option (`-c`).
+This is especially useful if you have specified options in the `REXE_OPTIONS` environment variable, 
+and want to ignore all of them.
+
+
 ### Comma Separated Requires and Loads
 
 For consistency with the `ruby` interpreter, `rexe` supports requires with the `-r` option, but 
@@ -536,6 +556,21 @@ also allows grouping them together using commas:
 
 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):
+
+```
+➜  ~   rexe -v 2>&1 | grep duration
+:duration_secs: 0.0012
+
+➜  ~   rexe -v -r nokogiri 2>&1 | grep duration
+:duration_secs: 0.148671
+```
+
+
+
 ### More Examples
 
 Here are some more examples to illustrate the use of `rexe`.
@@ -737,7 +772,7 @@ A word of caution though --
 the complexity and difficulty of sharing your `rexe` scripts across systems
 will be proportional to the extent to which you use environment variables
 and loaded files for configuration and shared code.
-Be responsible and disciplined in making this configuration and code as organized as possible.
+Be responsible and disciplined in making this configuration and code as clean and organized as possible.
 
 #### Footnotes
 

data/exe/rexe

@@ -5,18 +5,94 @@
 # Inspired by https://github.com/thisredone/rb
 
 require 'bundler'
+require 'date'
 require 'optparse'
+require 'ostruct'
 require 'shellwords'
 
 class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :requires, :verbose, :noop)
 
-  VERSION = '0.10.3'
+  VERSION = '0.11.0'
+
 
   def initialize
     clear_options
   end
 
 
+  def input_modes
+    @input_modes ||= {
+        'l' => :line,
+        'e' => :enumerator,
+        'b' => :one_big_string,
+        'n' => :no_input
+    }
+  end
+
+
+  def input_formats
+    @input_formats ||=  {
+        'j' => :json,
+        'm' => :marshal,
+        'n' => :none,
+        'y' => :yaml,
+    }
+  end
+
+
+  def input_parsers
+    @input_parsers ||= {
+        json:    ->(obj)  { JSON.parse(obj) },
+        marshal: ->(obj)  { Marshal.load(obj) },
+        none:    ->(obj)  { obj },
+        yaml:    ->(obj)  { YAML.load(obj) },
+    }
+  end
+
+
+  def output_formats
+    @output_formats ||= {
+        'a' => :awesome_print,
+        'i' => :inspect,
+        'j' => :json,
+        'J' => :pretty_json,
+        'm' => :marshal,
+        'n' => :no_output,
+        'p' => :puts,         # default
+        'P' => :pretty_print,
+        's' => :to_s,
+        'y' => :yaml,
+    }
+  end
+
+
+  def formatters
+    @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) },
+        pretty_print:  ->(obj)  { obj.pretty_inspect },
+        puts:          ->(obj)  { sio = StringIO.new; sio.puts(obj); sio.string },   # default
+        to_s:          ->(obj)  { obj.to_s + "\n" },
+        yaml:          ->(obj)  { obj.to_yaml },
+    }
+  end
+
+
+  def parser_and_format_requires
+    @format_requires ||= {
+        json:          'json',
+        pretty_json:   'json',
+        awesome_print: 'awesome_print',
+        pretty_print:  'pp',
+        yaml:          'yaml'
+    }
+  end
+
+
   # Used as an initializer and also when `-!` is specified on the command line.
   def clear_options
     self.input_format = :none
@@ -91,8 +167,6 @@ class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :req
 
   def parse_command_line
 
-    prepend_environment_options
-
     OptionParser.new do |parser|
 
       parser.on("-h", "--help", "Show help") do |_help_requested|
@@ -103,17 +177,10 @@ class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :req
       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]
+        self.input_format = input_formats[v]
         if self.input_format.nil?
           puts help_text
-          raise "Input mode must be one of #{modes.keys}."
+          raise "Input mode was '#{v}' but must be one of #{input_formats.keys}."
         end
       end
 
@@ -124,48 +191,30 @@ class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :req
           loadfiles = v.split(',').map(&:strip)
           existent, nonexistent = loadfiles.partition { |filespec| File.exists?(filespec) }
           if nonexistent.any?
-            log_if_verbose("\nDid not find the following files to load: #{nonexistent.to_s}\n\n")
+            raise("\nDid not find the following files to load: #{nonexistent.to_s}\n\n")
+          else
+            existent.each { |filespec| self.loads << filespec }
           end
-          existent.each { |filespec| self.loads << filespec }
         end
       end
 
       parser.on('-m', '--input_mode MODE',
                 'Mode with which to handle input (-ml, -me, -mb, -mn (default)') do |v|
 
-        modes = {
-            'l' => :line,
-            'e' => :enumerator,
-            'b' => :one_big_string,
-            'n' => :no_input
-        }
-
-        self.input_mode = modes[v]
+        self.input_mode = input_modes[v]
         if self.input_mode.nil?
           puts help_text
-          raise "Input mode must be one of #{modes.keys}."
+          raise "Input mode was '#{v}' but must be one of #{input_modes.keys}."
         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]
+        self.output_format = output_formats[v]
         if self.output_format.nil?
           puts help_text
-          raise "Output mode must be one of #{modes.keys}."
+          raise "Output mode was '#{v}' but must be one of #{output_formats.keys}."
         end
       end
 
@@ -208,12 +257,7 @@ class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :req
 
   def load_global_config_if_exists
     filespec = File.join(Dir.home, '.rexerc')
-    exists = File.exists?(filespec)
-    if exists
-      log_if_verbose("Loading global config file #{filespec}")
-      load(filespec)
-    end
-    exists ? filespec : nil
+    load(filespec) if File.exists?(filespec)
   end
 
 
@@ -231,62 +275,53 @@ class Rexe < Struct.new(:input_format, :input_mode, :loads, :output_format, :req
   end
 
 
-  def log_if_verbose(string)
-    STDERR.puts(string) if verbose
-  end
-
-
   def call
-    start_time = Time.now
+    start_time = DateTime.now
 
+    prepend_environment_options
     parse_command_line
-
-    log_if_verbose("rexe version #{VERSION} -- #{Time.now}")
-    log_if_verbose('Source Code: ' + ARGV.join(' '))
-    log_if_verbose('Options: ' + self.to_h.to_s)
+    user_source_code = ARGV.join(' ')
 
     requires.each { |r| require(r) }
-
     load_global_config_if_exists
-
     loads.each { |file| load(file) }
 
-    source_code = "Proc.new { #{ARGV.join(' ')} }"
-    code = eval(source_code)
+    callable = eval("Proc.new { #{user_source_code} }")
 
     actions = {
-        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(Object.new, code) }
+        line:           -> { STDIN.each { |l| execute(l.chomp, callable);            $RC[:count] += 1 } },
+        enumerator:     -> { execute(STDIN.each_line, callable);                     $RC[:count] += 1 },
+        one_big_string: -> { big_string = STDIN.read; execute(big_string, callable); $RC[:count] += 1 },
+        no_input:       -> { execute(Object.new, callable) }
     }
 
-    if self.noop
-      log_if_verbose("No-op mode requested; not executing code.")
-    else
-      actions[input_mode].()
+    # This global $RC (Rexe Context) OpenStruct is available in your user code.
+    # In order to make it possible to access this hash in your loaded files, we are not initializing
+    # the hash here; instead we add key/value pairs to it. This way, you can initialize a hash yourself
+    # in your loaded code.
+    $RC ||= OpenStruct.new
+    $RC.count         = 0
+    $RC.rexe_version  = VERSION
+    $RC.start_time    = start_time.iso8601
+    $RC.source_code   = user_source_code
+    $RC.options       = self.to_h
+
+    actions[input_mode].() unless self.noop
+
+    if verbose
+      $RC.duration_secs = Time.now - start_time.to_time
+      require 'yaml'
+      STDERR.puts($RC.to_h.to_yaml)
     end
-
-    duration = Time.now - start_time
-    log_if_verbose("rexe time elapsed: #{duration} seconds.")
   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]
+    require_spec = parser_and_format_requires[input_format]
+    require require_spec if require_spec
+    @input_parser = input_parsers[input_format]
   end
   @input_parser
 end
@@ -294,27 +329,8 @@ 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 },
-    }
-
+    require_spec = parser_and_format_requires[output_format]
+    require require_spec if require_spec
     @output_formatter = formatters[output_format]
   end
   @output_formatter

metadata

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