rexe 0.13.0 → 0.14.0

data/exe/rexe

@@ -12,12 +12,13 @@ require 'shellwords'
 
 class Rexe
 
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 
   PROJECT_URL = 'https://github.com/keithrbennett/rexe'
 
 
   class Options < Struct.new(
+      :input_filespec,
       :input_format,
       :input_mode,
       :loads,
@@ -34,13 +35,14 @@ class Rexe
 
 
     def clear
-      self.input_format  = :none
-      self.input_mode    = :no_input
-      self.output_format = :puts
-      self.loads         = []
-      self.requires      = []
-      self.log_format    = :none
-      self.noop          = false
+      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
     end
   end
 
@@ -54,7 +56,7 @@ class Rexe
           'l' => :line,
           'e' => :enumerator,
           'b' => :one_big_string,
-          'n' => :no_input
+          'n' => :none
       }
     end
 
@@ -86,7 +88,7 @@ class Rexe
           'j' => :json,
           'J' => :pretty_json,
           'm' => :marshal,
-          'n' => :no_output,
+          'n' => :none,
           'p' => :puts,         # default
           'P' => :pretty_print,
           's' => :to_s,
@@ -101,7 +103,7 @@ class Rexe
           inspect:       ->(obj)  { obj.inspect + "\n" },
           json:          ->(obj)  { obj.to_json },
           marshal:       ->(obj)  { Marshal.dump(obj) },
-          no_output:     ->(_obj) { nil },
+          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
@@ -123,42 +125,54 @@ class Rexe
 
 
 
-  attr_reader :callable, :input_parser, :lookups, :options, :output_formatter,
-                :log_formatter, :start_time, :user_source_code
+  class CommandLineParser
 
+    attr_reader :lookups, :options
 
-  def initialize
-    @start_time = DateTime.now
-    @options = Options.new
-    @lookups = Lookups.new
-  end
+    def initialize
+      @lookups = Lookups.new
+      @options = Options.new
+    end
 
 
-  # Requires the 'require' appropriate to the specified format.
-  private def require_format_require(format)
-    r = lookups.format_requires[format]
-    require!(r) if r
-  end
+    # Inserts contents of REXE_OPTIONS environment variable at the beginning of ARGV.
+    private def prepend_environment_options
+      env_opt_string = ENV['REXE_OPTIONS']
+      if env_opt_string
+        args_to_prepend = Shellwords.shellsplit(env_opt_string)
+        ARGV.unshift(args_to_prepend).flatten!
+      end
+    end
+
+
+    def add_format_requires_to_requires_list
+      formats = [options.input_format, options.output_format, options.log_format]
+      requires = formats.map { |format| lookups.format_requires[format] }.uniq.compact
+      requires.each { |r| options.requires << r }
+    end
 
 
-  def help_text
-    <<~HEREDOC
+    def help_text
+      <<~HEREDOC
 
     rexe -- Ruby Command Line Executor/Filter -- v#{VERSION} -- #{PROJECT_URL}
 
-    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
@@ -174,8 +188,8 @@ class Rexe
                                  -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;
@@ -187,273 +201,299 @@ class Rexe
     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"`)
 
-    HEREDOC
-  end
-
-
-  # Inserts contents of REXE_OPTIONS environment variable at the beginning of ARGV.
-  private def prepend_environment_options
-    env_opt_string = ENV['REXE_OPTIONS']
-    if env_opt_string
-      args_to_prepend = Shellwords.shellsplit(env_opt_string)
-      ARGV.unshift(args_to_prepend).flatten!
+      HEREDOC
     end
-  end
 
 
-  def open_resource(resource_identifier)
-    command = case (`uname`.chomp)
-    when 'Darwin'
-      'open'
-    when 'Linux'
-      'xdg-open'
-    else
-      'start'
+    # File file input mode; detects the input mode (JSON, YAML, or None) from the extension.
+    def autodetect_file_format(filespec)
+      extension = File.extname(filespec).downcase
+      if extension == '.json'
+        :json
+      elsif extension == '.yml' || extension == '.yaml'
+        :yaml
+      else
+        :none
+      end
     end
 
-    `#{command} #{resource_identifier}`
-  end
-
 
-  def add_format_requires_to_requires_list
-    formats = [options.input_format, options.output_format, options.log_format]
-    requires = formats.map { |format| lookups.format_requires[format] }.uniq.compact
-    requires.each { |r| options.requires << r }
-  end
+    # Using 'optparse', parses the command line.
+    # Settings go into this instance's properties (see Struct declaration).
+    def parse
 
+      prepend_environment_options
 
-  # Using 'optparse', parses the command line.
-  # Settings go into this instance's properties (see Struct declaration).
-  private def parse_command_line
+      OptionParser.new do |parser|
 
-    OptionParser.new do |parser|
 
-      parser.on('-g', '--log_format FORMAT', 'Log format, logs to stderr, defaults to none (see -o for format options)') do |v|
-        options.log_format = lookups.output_formats[v]
-        if options.log_format.nil?
-          puts help_text
-          raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}."
+        parser.on('-f', '--input_file FILESPEC',
+            'Use this file instead of stdin; autodetects YAML and JSON file extensions') do |v|
+          unless File.exist?(v)
+            raise "File #{v} does not exist."
+          end
+          options.input_filespec = v
+          options.input_format = autodetect_file_format(v)
+          if [:json, :yaml].include?(options.input_format)
+            options.input_mode = :one_big_string
+          end
         end
-      end
 
-      parser.on("-h", "--help", "Show help") do |_help_requested|
-        puts help_text
-        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|
+        parser.on('-g', '--log_format FORMAT', 'Log format, logs to stderr, defaults to none (see -o for format options)') do |v|
+          options.log_format = lookups.output_formats[v]
+          if options.log_format.nil?
+            puts help_text
+            raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}."
+          end
+        end
 
-        options.input_format = lookups.input_formats[v]
-        if options.input_format.nil?
+        parser.on("-h", "--help", "Show help") do |_help_requested|
           puts help_text
-          raise "Input mode was '#{v}' but must be one of #{lookups.input_formats.keys}."
+          exit
         end
-      end
 
-      parser.on('-l', '--load RUBY_FILE(S)', 'Ruby file(s) to load, comma separated, or ! to clear') do |v|
-        if v == '!'
-          options.loads.clear
-        else
-          loadfiles = v.split(',').map(&:strip)
-          removes, adds = loadfiles.partition { |filespec| filespec[0] == '-' }
+        parser.on('-i', '--input_format FORMAT',
+                  'Mode with which to parse input values (n = none (default), j = JSON, m = Marshal, y = YAML') do |v|
 
-          existent, nonexistent = adds.partition { |filespec| File.exists?(filespec) }
-          if nonexistent.any?
-            raise("\nDid not find the following files to load: #{nonexistent}\n\n")
-          else
-            existent.each { |filespec| options.loads << filespec }
+          options.input_format = lookups.input_formats[v]
+          if options.input_format.nil?
+            puts help_text
+            raise "Input mode was '#{v}' but must be one of #{lookups.input_formats.keys}."
           end
+        end
+
+        parser.on('-l', '--load RUBY_FILE(S)', 'Ruby file(s) to load, comma separated, or ! to clear') do |v|
+          if v == '!'
+            options.loads.clear
+          else
+            loadfiles = v.split(',').map(&:strip).map { |s| File.expand_path(s) }
+            removes, adds = loadfiles.partition { |filespec| filespec[0] == '-' }
 
-          removes.each { |filespec| options.loads -= [filespec[1..-1]] }
+            existent, nonexistent = adds.partition { |filespec| File.exists?(filespec) }
+            if nonexistent.any?
+              raise("\nDid not find the following files to load: #{nonexistent}\n\n")
+            else
+              existent.each { |filespec| options.loads << filespec }
+            end
+
+            removes.each { |filespec| options.loads -= [filespec[1..-1]] }
+          end
         end
-      end
 
-      parser.on('-m', '--input_mode MODE',
-                'Mode with which to handle input (-ml, -me, -mb, -mn (default)') do |v|
+        parser.on('-m', '--input_mode MODE',
+                  'Mode with which to handle input (-ml, -me, -mb, -mn (default)') do |v|
 
-        options.input_mode = lookups.input_modes[v]
-        if options.input_mode.nil?
-          puts help_text
-          raise "Input mode was '#{v}' but must be one of #{lookups.input_modes.keys}."
+          options.input_mode = lookups.input_modes[v]
+          if options.input_mode.nil?
+            puts help_text
+            raise "Input mode was '#{v}' but must be one of #{lookups.input_modes.keys}."
+          end
         end
-      end
 
-      parser.on('-o', '--output_format FORMAT',
-                'Mode with which to format values for output (`-o` + [aijJmnpsy])') do |v|
+        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?
-          puts help_text
-          raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}."
+          options.output_format = lookups.output_formats[v]
+          if options.output_format.nil?
+            puts help_text
+            raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}."
+          end
         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 == '!'
-          options.requires.clear
-        else
-          v.split(',').map(&:strip).each do |r|
-            if r[0] == '-'
-              options.requires -= [r[1..-1]]
-            else
-              options.requires << r
+        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 == '!'
+            options.requires.clear
+          else
+            v.split(',').map(&:strip).each do |r|
+              if r[0] == '-'
+                options.requires -= [r[1..-1]]
+              else
+                options.requires << r
+              end
             end
           end
         end
-      end
 
-      parser.on('-c', '--clear_options', "Clear all previous command line options") do |v|
-        options.clear
-      end
+        parser.on('-c', '--clear_options', "Clear all previous command line options") do |v|
+          options.clear
+        end
 
-      # 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:
-      # -n no, -n yes, -n false, -n true, -n n, -n y, -n +, but not -n -.
-      parser.on('-n', '--[no-]noop [FLAG]', TrueClass, "Do not execute the code (useful with -g)") do |v|
-        options.noop = (v.nil? ? true : v)
-      end
+        # 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:
+        # -n no, -n yes, -n false, -n true, -n n, -n y, -n +, but not -n -.
+        parser.on('-n', '--[no-]noop [FLAG]', TrueClass, "Do not execute the code (useful with -g)") do |v|
+          options.noop = (v.nil? ? true : v)
+        end
 
-      parser.on('-v', '--version', 'Print version') do
-        puts VERSION
-        exit
-      end
+        parser.on('-v', '--version', 'Print version') do
+          puts VERSION
+          exit
+        end
 
-      # Undocumented feature
-      parser.on('', '--open-project') do
-        open_resource(PROJECT_URL)
-        exit(0)
-      end
+        # Undocumented feature
+        parser.on('', '--open-project') do
+          open_resource(PROJECT_URL)
+          exit(0)
+        end
+
+      end.parse!
 
-    end.parse!
+      # We want to do this after all options have been processed because we don't want any clearing of the
+      # options (by '-c', etc.) to result in exclusion of these needed requires.
+      add_format_requires_to_requires_list
 
-    # We want to do this after all options have been processed because we don't want any clearing of the
-    # options (by '-c', etc.) to result in exclusion of these needed requires.
-    add_format_requires_to_requires_list
+      options.requires = options.requires.sort.uniq
+      options.loads.uniq!
 
-    options.requires.uniq!
-    options.loads.uniq!
+      options
 
+    end
   end
 
 
-  private def load_global_config_if_exists
-    filespec = File.join(Dir.home, '.rexerc')
-    load(filespec) if File.exists?(filespec)
-  end
+  class Main
 
+    attr_reader :callable, :input_parser, :lookups,
+                :options, :output_formatter,
+                :log_formatter, :start_time, :user_source_code
 
-  private def init_parser_and_formatters
-    @input_parser     = lookups.input_parsers[options.input_format]
-    @output_formatter = lookups.formatters[options.output_format]
-    @log_formatter    = lookups.formatters[options.log_format]
-  end
+
+    def initialize
+      @lookups = Lookups.new
+      @start_time = DateTime.now
+    end
 
 
-  # Executes the user specified code in the manner appropriate to the input mode.
-  # Performs any optionally specified parsing on input and formatting on output.
-  private def execute(eval_context_object, code)
-    if options.input_format != :none && options.input_mode != :no_input
-      eval_context_object = input_parser.(eval_context_object)
+    def open_resource(resource_identifier)
+      command = case (`uname`.chomp)
+      when 'Darwin'
+        'open'
+      when 'Linux'
+        'xdg-open'
+      else
+        'start'
+      end
+
+      `#{command} #{resource_identifier}`
     end
 
-    value = eval_context_object.instance_eval(&code)
 
-    unless options.output_format == :no_output
-      print output_formatter.(value)
+    private def load_global_config_if_exists
+      filespec = File.join(Dir.home, '.rexerc')
+      load(filespec) if File.exists?(filespec)
     end
-  rescue Errno::EPIPE
-    exit(-13)
-  end
 
 
-  # The global $RC (Rexe Context) OpenStruct is available in your user code.
-  # In order to make it possible to access this object in your loaded files, we are not creating
-  # it here; instead we add properties to it. This way, you can initialize an OpenStruct yourself
-  # in your loaded code and it will still work. If you do that, beware, any properties you add will be
-  # included in the log output. If the to_s of your added objects is large, that might be a pain.
-  private def init_rexe_context
-    $RC ||= OpenStruct.new
-    $RC.count         = 0
-    $RC.rexe_version  = VERSION
-    $RC.start_time    = start_time.iso8601
-    $RC.source_code   = user_source_code
-    $RC.options       = options.to_h
-
-    def $RC.i; count end  # `i` aliases `count` so you can more concisely get the count in your user code
-  end
+    private def init_parser_and_formatters
+      @input_parser     = lookups.input_parsers[options.input_format]
+      @output_formatter = lookups.formatters[options.output_format]
+      @log_formatter    = lookups.formatters[options.log_format]
+    end
+
+
+    # Executes the user specified code in the manner appropriate to the input mode.
+    # Performs any optionally specified parsing on input and formatting on output.
+    private def execute(eval_context_object, code)
+      if options.input_format != :none && options.input_mode != :none
+        eval_context_object = input_parser.(eval_context_object)
+      end
 
+      value = eval_context_object.instance_eval(&code)
 
-  private def create_callable
-    if user_source_code.empty? && (! options.noop)
-      STDERR.puts "No source code provided.  Use -h to display help."
-      exit(-1)
+      unless options.output_format == :none
+        print output_formatter.(value)
+      end
+    rescue Errno::EPIPE
+      exit(-13)
     end
 
-    eval("Proc.new { #{user_source_code} }")
-  end
 
+    # The global $RC (Rexe Context) OpenStruct is available in your user code.
+    # In order to make it possible to access this object in your loaded files, we are not creating
+    # it here; instead we add properties to it. This way, you can initialize an OpenStruct yourself
+    # in your loaded code and it will still work. If you do that, beware, any properties you add will be
+    # included in the log output. If the to_s of your added objects is large, that might be a pain.
+    private def init_rexe_context
+      $RC ||= OpenStruct.new
+      $RC.count         = 0
+      $RC.rexe_version  = VERSION
+      $RC.start_time    = start_time.iso8601
+      $RC.source_code   = user_source_code
+      $RC.options       = options.to_h
+
+      def $RC.i; count end  # `i` aliases `count` so you can more concisely get the count in your user code
+    end
 
-  private def lookup_action(mode)
-    {
-        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) }
-    }[mode]
-  end
 
+    private def create_callable
+      if user_source_code.empty? && (! options.noop)
+        raise "No source code provided.  Use -h to display help."
+      end
 
-  private def output_log_entry
-    if options.log_format != :none
-      $RC.duration_secs = Time.now - start_time.to_time
-      STDERR.puts(log_formatter.($RC.to_h))
+      eval("Proc.new { #{user_source_code} }")
     end
-  end
 
 
-  # Bypasses Bundler's restriction on loading gems
-  # (see https://stackoverflow.com/questions/55144094/bundler-doesnt-permit-using-gems-in-project-home-directory)
-  private def require!(the_require)
-    begin
-      require the_require
-    rescue LoadError => error
-      gem_path = `gem which #{the_require}`
-      if gem_path.chomp.strip.empty?
-        raise error # re-raise the error, can't fix it
-      else
-        load_dir = File.dirname(gem_path)
-        $LOAD_PATH << load_dir
+    private def lookup_action(mode)
+      input = options.input_filespec ? File.open(options.input_filespec) : STDIN
+      {
+          line:           -> { input.each { |l| execute(l.chomp, callable);            $RC.count += 1 } },
+          enumerator:     -> { execute(input.each_line, callable);                     $RC.count += 1 },
+          one_big_string: -> { big_string = input.read; execute(big_string, callable); $RC.count += 1 },
+          none:           -> { execute(Object.new, callable) }
+      }.fetch(mode)
+    end
+
+
+    private def output_log_entry
+      if options.log_format != :none
+        $RC.duration_secs = Time.now - start_time.to_time
+        STDERR.puts(log_formatter.($RC.to_h))
+      end
+    end
+
+
+    # Bypasses Bundler's restriction on loading gems
+    # (see https://stackoverflow.com/questions/55144094/bundler-doesnt-permit-using-gems-in-project-home-directory)
+    private def require!(the_require)
+      begin
         require the_require
+      rescue LoadError => error
+        gem_path = `gem which #{the_require}`
+        if gem_path.chomp.strip.empty?
+          raise error # re-raise the error, can't fix it
+        else
+          load_dir = File.dirname(gem_path)
+          $LOAD_PATH << load_dir
+          require the_require
+        end
       end
     end
-  end
 
 
-  # This class' entry point.
-  def call
+    # This class' entry point.
+    def call
 
-    prepend_environment_options
-    parse_command_line
+      @options = CommandLineParser.new.parse
 
-    options.requires.each { |r| require!(r) }
-    load_global_config_if_exists
-    options.loads.each { |file| load(file) }
+      options.requires.each { |r| require!(r) }
+      load_global_config_if_exists
+      options.loads.each { |file| load(file) }
 
-    @user_source_code = ARGV.join(' ')
-    @callable = create_callable
+      @user_source_code = ARGV.join(' ')
+      @callable = create_callable
 
-    init_rexe_context
-    init_parser_and_formatters
+      init_rexe_context
+      init_parser_and_formatters
 
-    # This is where the user's source code will be executed; the action will in turn call `execute`.
-    lookup_action(options.input_mode).call unless options.noop
+      # This is where the user's source code will be executed; the action will in turn call `execute`.
+      lookup_action(options.input_mode).call unless options.noop
 
-    output_log_entry
+      output_log_entry
+    end
   end
 end
 
-
-Bundler.with_clean_env { Rexe.new.call }
+Bundler.with_clean_env { Rexe::Main.new.call }