rexe 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfda8c2ee84b6747e85e1ba54954fefab0da7e246916808994c67976b291e714
-  data.tar.gz: c2221ed77248835efaf56f0f10ffe31803eca929760f67b0c274ac2ed4c1d423
+  metadata.gz: 0347c7ba27865d64bda5d52cbf087f562d03dc4aad20b1ad1560c77c3611e6ad
+  data.tar.gz: c1ca00237ac7bd2266d13c7802099978669619a758426374967530d004b15e43
 SHA512:
-  metadata.gz: 4b6809b8e4dc6b66cca019993eed4cfcddb65a80c75abcfccb9986206f8f59c1e2d3f4c128bff587899a24c32aeb13a082b5b597ada934b785390f9322ae46c7
-  data.tar.gz: 5127aa52ded297c3a53529b23174f6ec1fa397c59033fd4da5bca0adc700eccd12327c84abab9e644171384a1cabf653a523bbcee8dd96b8ea4abdf17a049243
+  metadata.gz: c786623473eaed89cb5b72033b727bbac7dae299286b5fe685a2e16762e04a5e5d5d936bd9b98be96e84d4de1e168a64a1b1d7b054c6a92557a7671cbc14d31e
+  data.tar.gz: 6bd1bad2eaee29545f26e5cef1de3c7c5204723af7d0541792cdbf11806fed8fe55b845a878cdf53c44ebe19cb00026a8c9825b6e5385fefc9a776dead735a51

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 ## rexe -- Ruby Command Line Executor
 
 
+### v0.4.0
+
+* Add -u option for loading files at current directory or above.
+* Fix command line option handling for disabling verbose mode previously enabled.
+* Improve README.
+
+
 ### v0.3.1
 
 * Help text fixes.

data/README.md

@@ -26,30 +26,28 @@ rexe is a _filter_ in that it can consume standard input and emit standard outpu
 As a summary, here is the help text printed out by the application:
 
 ```
-
-
-rexe -- Ruby Command Line Filter -- v1.1.0 -- https://github.com/keithrbennett/rexe
+exe -- Ruby Command Line Filter -- v0.3.1 -- https://github.com/keithrbennett/rexe
 
 Optionally takes standard input and runs the specified code on it, sending the result to standard output.
 
 Options:
 
--h, --help               Print help and exit
--l, --load A_RUBY_FILE   Load this Ruby source code file
--m, --mode MODE          Mode with which to handle input (i.e. what `self` will be in the code):
+-h, --help                  Print help and exit
+-l, --load RUBY_FILE(S)     Ruby file(s) to load, comma separated
+-u, --load-up RUBY_FILE(S)  Ruby file(s) to load, searching up tree, comma separated
+-m, --mode MODE             Mode with which to handle input (i.e. what `self` will be in the code):
                            -ms for each line to be handled separately as a string (default)
                            -me for an enumerator of lines (least memory consumption for big data)
                            -mb for 1 big string (all lines combined into single multiline string)
-                           -mn to execute the specified Ruby code on no input at all 
+                           -mn to execute the specified Ruby code on no input at all
 -r, --require REQUIRES   Gems and built-in libraries (e.g. shellwords, yaml) to require, comma separated
--v, --[no-]verbose       Verbose mode, writes to stderr
+-v, --[no-]verbose       Verbose mode (logs to stderr) Verbose off short options: -v n, -v false
 
-If there is an .rexerc file in your home directory, it will be run as Ruby code 
+If there is an .rexerc file in your home directory, it will be run as Ruby code
 before processing the input.
 
 If there is an 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"`)
-
 ```
 
 ### Input Mode
@@ -73,6 +71,13 @@ Other Ruby files can be loaded by `rexe`, to, for example, define classes and me
 
 If there is a file named `.rexerc` in the home directory, that will always be loaded without explicitly requesting it on the command line.
 
+#### Searching for Load Files in the Current Directory and Above
+
+Using the `-u` option, you can specify that the file you want to load should be searched for at the specified directory _and above_. This can be handy when you have project specific configuration and you may be multiple levels below the project root.
+
+For example, if you run `rexe` from `~/my_project/a/b/c`, and specify `-u load-me.rb`, and `load-me.rb` is located in `~/my_project`, then it will be loaded from there.
+
+If the file is not found, the failure will be silent and the program will proceed. (Preferred behavior could go either way on this, but the current approach enables you to unconditionally specify a `-u` file in your default `REXE_OPTIONS` environment variable value and have it work regardless of the presence or absence of the file.) If verbose mode is enabled, a message about the failure to find the file will be displayed.
 
 ### Verbose Mode
 
@@ -81,17 +86,44 @@ Verbose mode outputs information to standard error (stderr). This information ca
 Here is an example of some text that might be output in verbose mode:
 
 ```
-rexe version 1.1.0 -- 2019-02-04 21:50:34 +0700
-Source Code: sort.to_a.first(3).ai
-Requiring awesome_print
+➜  ~   rexe -r yaml -mn -v "%w(foo bar baz).to_yaml"
+rexe version 0.3.0 -- 2019-02-08 02:21:27 +0700
+Source Code: %w(foo bar baz).to_yaml
+Options: {:input_mode=>:no_input, :loads=>[], :requires=>["yaml"], :verbose=>true}
 Loading global config file /Users/kbennett/.rexerc
+---
+- foo
+- bar
+- baz
+rexe time elapsed: 0.03874 seconds.
 ```
 
+To set verbose mode _off_ on the command line, the option parser accepts the long option `--no-verbose`, of course, but you could use instead `-v false` or `-v n`. If you should need to pass a value to `-v` to turn verbose mode _on_, then you can use `-v y` or `-v true`. 
+
 ### The REXE_OPTIONS Environment Variable
 
 Very often you will want to call `rexe` several times with similar options. Instead of having to clutter the command line each time with these options, you can put them in an environment variable named `REXE_OPTIONS`, and they will be prepended automatically. Since they will be processed before the options on the command line, they are of lower precedence and can be overridden.
 
 
+### The ~/.rexerc Configuation File
+
+The `.rexerc` file in your home directory (if it exists) is loaded unconditionally. Here is a place to put things that you will _always_ want. You can include commonly needed requires, but be careful because the impact on startup time may be more than you want. You can test this using verbose mode, which outputs the execution time after completing.
+
+
+### Directory-Specific Configuration Files
+
+Although there is no built-in feature for directory-specific configuration files, this can be easily accomplished by inserting something like this in your global configuration file (~/.rexerc):
+
+```
+dir_specific_config_file = './rexe.rc'
+load dir_specific_config_file' if File.exist?(dir_specific_config_file)
+```
+ 
+You should probably put this at the very end of this global configuration file so that the directory specific file will always be able to override global settings.
+
+Note that the directory specific filename used differs from the global config filename. This is a) so that there is no recursive loading of the file when in the home directory, and b) because it is more convenient for these files that they not be hidden.
+
+
 ## Troubleshooting
 
 One common problem relates to the shell's special handling of characters. Remember that the shell will process special characters, thereby changing your text before passing it on to the Ruby code. It is good to get in the habit of putting your source code in double quotes; and if the source code itself uses quotes, use `q{}` or `Q{}` instead. For example:

data/exe/rexe

@@ -4,14 +4,13 @@
 #
 # Inspired by https://github.com/thisredone/rb
 
-
 require 'optparse'
 require 'shellwords'
 
-# Rexe - Ruby Executor
+
 class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose)
 
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 
   def initialize
     self.input_mode = :string
@@ -30,15 +29,16 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose)
 
     Options:
 
-    -h, --help               Print help and exit
-    -l, --load RUBY_FILE(S)  Ruby file(s) to load, comma separated
-    -m, --mode MODE          Mode with which to handle input (i.e. what `self` will be in the code):
+    -h, --help                  Print help and exit
+    -l, --load RUBY_FILE(S)     Ruby file(s) to load, comma separated
+    -u, --load-up RUBY_FILE(S)  Ruby file(s) to load, searching up tree, comma separated
+    -m, --mode MODE             Mode with which to handle input (i.e. what `self` will be in the code):
                                -ms for each line to be handled separately as a string (default)
                                -me for an enumerator of lines (least memory consumption for big data)
                                -mb for 1 big string (all lines combined into single multiline string)
                                -mn to execute the specified Ruby code on no input at all 
     -r, --require REQUIRES   Gems and built-in libraries (e.g. shellwords, yaml) to require, comma separated
-    -v, --[no-]verbose       Verbose mode (logs to stderr)
+    -v, --[no-]verbose       Verbose mode (logs to stderr) Verbose off short options: -v n, -v false
 
     If there is an .rexerc file in your home directory, it will be run as Ruby code 
     before processing the input.
@@ -62,10 +62,6 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose)
   def parse_command_line
     prepend_environment_options
 
-    add_comma_sep_tokens_to_array = ->(string, array) do
-      string.split(',').map(&:strip).each { |r| array << r }
-    end
-
     OptionParser.new do |parser|
 
       parser.on("-h", "--help", "Show help") do |_help_requested|
@@ -74,7 +70,19 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose)
       end
 
       parser.on('-l', '--load RUBY_FILE(S)', 'Ruby file(s) to load, comma separated') do |v|
-        add_comma_sep_tokens_to_array.(v, self.loads)
+        v.split(',').map(&:strip).each { |r| self.loads << r }
+      end
+
+      parser.on('-u', '--load_up RUBY_FILE(S)', 'Ruby file(s) to load, searching up tree, comma separated') do |v|
+        filespecs = v.split(',').map(&:strip)
+        filespecs.each do |filespec|
+          found_file = find_file_up_tree(filespec)
+          if found_file
+            self.loads << found_file
+          else
+            log_if_verbose("Did not find load file #{filespec} in this directory or higher.")
+          end
+        end
       end
 
       parser.on('-m', '--mode MODE',
@@ -99,13 +107,32 @@ class Rexe < Struct.new(:input_mode, :loads, :requires, :verbose)
         add_comma_sep_tokens_to_array.(v, self.requires)
       end
 
-      parser.on('-v', '--[no-]verbose', 'Verbose mode (logs to stderr)') do |v|
-        self.verbose = v
+      # See https://stackoverflow.com/questions/54576873/ruby-optionparser-short-code-for-boolean-option
+      # for an excellent explanation of this optparse incantation.
+      # According to the answer, valid options are:
+      # -v no, -v yes, -v false, -v true, -v n, -v y, -v +, but not -v -.
+      parser.on('-v', '--[no-]verbose [FLAG]', TrueClass, 'Verbose mode (logs to stderr)') do |v|
+        self.verbose = (v.nil? ? true : v)
       end
     end.parse!
   end
 
 
+  # Looks in this directory and all above it for the filename
+  # @return the first match found, or nil if none
+  def find_file_up_tree(filespec)
+    filespec = File.expand_path(filespec)
+    basename = File.basename(filespec)
+
+    loop do
+      return filespec if File.exist?(filespec)
+      return nil if File.dirname(filespec) == File::SEPARATOR
+      new_dir = File.expand_path(File.join(File.dirname(filespec), '..'))
+      filespec = File.join(new_dir, basename)
+    end
+  end
+
+
   def load_global_config_if_exists
     filespec = File.join(Dir.home, '.rexerc')
     exists = File.exists?(filespec)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rexe
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-07 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler