rexe 0.12.0 → 0.13.0

data/exe/rexe

@@ -10,115 +10,141 @@ require 'optparse'
 require 'ostruct'
 require 'shellwords'
 
-class Rexe < Struct.new(
-    :input_format,
-    :input_mode,
-    :loads,
-    :output_format,
-    :requires,
-    :log_format,
-    :noop)
+class Rexe
 
+  VERSION = '0.13.0'
 
-  VERSION = '0.12.0'
+  PROJECT_URL = 'https://github.com/keithrbennett/rexe'
 
 
-  def initialize
-    clear_options
-  end
+  class Options < Struct.new(
+      :input_format,
+      :input_mode,
+      :loads,
+      :output_format,
+      :requires,
+      :log_format,
+      :noop)
 
 
-  def input_modes
-    @input_modes ||= {
-        'l' => :line,
-        'e' => :enumerator,
-        'b' => :one_big_string,
-        'n' => :no_input
-    }
-  end
+    def initialize
+      super
+      clear
+    end
 
 
-  def input_formats
-    @input_formats ||=  {
-        'j' => :json,
-        'm' => :marshal,
-        'n' => :none,
-        'y' => :yaml,
-    }
+    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
+    end
   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
 
+  class Lookups
+    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 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 },
-    }
+
+    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 format_requires
+      @format_requires ||= {
+          json:          'json',
+          pretty_json:   'json',
+          awesome_print: 'awesome_print',
+          pretty_print:  'pp',
+          yaml:          'yaml'
+      }
+    end
   end
 
 
-  def require_format_require(format)
-    @format_requires ||= {
-        json:          'json',
-        pretty_json:   'json',
-        awesome_print: 'awesome_print',
-        pretty_print:  'pp',
-        yaml:          'yaml'
-    }
-    r = @format_requires[format]
-    require(r) if r
+
+  attr_reader :callable, :input_parser, :lookups, :options, :output_formatter,
+                :log_formatter, :start_time, :user_source_code
+
+
+  def initialize
+    @start_time = DateTime.now
+    @options = Options.new
+    @lookups = Lookups.new
   end
 
 
-  # Used as an initializer and also when `-!` is specified on the command line.
-  def clear_options
-    self.input_format  = :none
-    self.input_mode    = :no_input
-    self.output_format = :puts
-    self.loads         = []
-    self.requires      = []
-    self.log_format    = :none
-    self.noop          = false
+  # Requires the 'require' appropriate to the specified format.
+  private def require_format_require(format)
+    r = lookups.format_requires[format]
+    require!(r) if r
   end
 
 
   def help_text
     <<~HEREDOC
 
-    rexe -- Ruby Command Line Executor/Filter -- v#{VERSION} -- https://github.com/keithrbennett/rexe
+    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.
 
@@ -134,7 +160,8 @@ class Rexe < Struct.new(
                                  -im  Marshal
                                  -in  None
                                  -iy  YAML
-    -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated, or ! to clear
+    -l, --load RUBY_FILE(S)    Ruby file(s) to load, comma separated;
+                                 ! to clear all, or precede a name with '-' to remove
     -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
@@ -151,7 +178,8 @@ class Rexe < Struct.new(
                                  -op  Puts (default)
                                  -os  to_s
                                  -oy  YAML
-    -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated, or ! to clear
+    -r, --require REQUIRE(S)   Gems and built-in libraries to require, comma separated;
+                                 ! to clear all, or precede a name with '-' to remove
 
     If there is an .rexerc file in your home directory, it will be run as Ruby code 
     before processing the input.
@@ -163,7 +191,8 @@ class Rexe < Struct.new(
   end
 
 
-  def prepend_environment_options
+  # 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)
@@ -172,15 +201,38 @@ class Rexe < Struct.new(
   end
 
 
-  def parse_command_line
+  def open_resource(resource_identifier)
+    command = case (`uname`.chomp)
+    when 'Darwin'
+      'open'
+    when 'Linux'
+      'xdg-open'
+    else
+      'start'
+    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).
+  private def parse_command_line
 
     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|
-        self.log_format = output_formats[v]
-        if self.log_format.nil?
+        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 #{output_formats.keys}."
+          raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.keys}."
         end
       end
 
@@ -192,58 +244,68 @@ class Rexe < Struct.new(
       parser.on('-i', '--input_format FORMAT',
                 'Mode with which to parse input values (n = none (default), j = JSON, m = Marshal, y = YAML') do |v|
 
-        self.input_format = input_formats[v]
-        if self.input_format.nil?
+        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 #{input_formats.keys}."
+          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 == '!'
-          self.loads.clear
+          options.loads.clear
         else
           loadfiles = v.split(',').map(&:strip)
-          existent, nonexistent = loadfiles.partition { |filespec| File.exists?(filespec) }
+          removes, adds = loadfiles.partition { |filespec| filespec[0] == '-' }
+
+          existent, nonexistent = adds.partition { |filespec| File.exists?(filespec) }
           if nonexistent.any?
-            raise("\nDid not find the following files to load: #{nonexistent.to_s}\n\n")
+            raise("\nDid not find the following files to load: #{nonexistent}\n\n")
           else
-            existent.each { |filespec| self.loads << filespec }
+            existent.each { |filespec| options.loads << filespec }
           end
+
+          removes.each { |filespec| options.loads -= [filespec[1..-1]] }
         end
       end
 
       parser.on('-m', '--input_mode MODE',
                 'Mode with which to handle input (-ml, -me, -mb, -mn (default)') do |v|
 
-        self.input_mode = input_modes[v]
-        if self.input_mode.nil?
+        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 #{input_modes.keys}."
+          raise "Input mode was '#{v}' but must be one of #{lookups.input_modes.keys}."
         end
       end
 
       parser.on('-o', '--output_format FORMAT',
                 'Mode with which to format values for output (`-o` + [aijJmnpsy])') do |v|
 
-        self.output_format = output_formats[v]
-        if self.output_format.nil?
+        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 #{output_formats.keys}."
+          raise "Output mode was '#{v}' but must be one of #{lookups.output_formats.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 == '!'
-          self.requires.clear
+          options.requires.clear
         else
-          v.split(',').map(&:strip).each { |r| self.requires << r }
+          v.split(',').map(&:strip).each do |r|
+            if r[0] == '-'
+              options.requires -= [r[1..-1]]
+            else
+              options.requires << r
+            end
+          end
         end
       end
 
       parser.on('-c', '--clear_options', "Clear all previous command line options") do |v|
-        clear_options
+        options.clear
       end
 
       # See https://stackoverflow.com/questions/54576873/ruby-optionparser-short-code-for-boolean-option
@@ -251,34 +313,55 @@ class Rexe < Struct.new(
       # 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|
-        self.noop = (v.nil? ? true : v)
+        options.noop = (v.nil? ? true : v)
       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
+
     end.parse!
 
-    requires.uniq!
-    loads.uniq!
+    # 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.uniq!
+    options.loads.uniq!
 
   end
 
 
-  def load_global_config_if_exists
+  private def load_global_config_if_exists
     filespec = File.join(Dir.home, '.rexerc')
     load(filespec) if File.exists?(filespec)
   end
 
 
-  def execute(eval_context_object, code)
-    if input_format != :none && input_mode != :no_input
+  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 != :no_input
       eval_context_object = input_parser.(eval_context_object)
     end
 
     value = eval_context_object.instance_eval(&code)
-    unless output_format == :no_output
+
+    unless options.output_format == :no_output
       print output_formatter.(value)
     end
   rescue Errno::EPIPE
@@ -286,84 +369,91 @@ class Rexe < Struct.new(
   end
 
 
-  def call
-    start_time = DateTime.now
+  # 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
 
-    prepend_environment_options
-    parse_command_line
+    def $RC.i; count end  # `i` aliases `count` so you can more concisely get the count in your user code
+  end
 
-    user_source_code = ARGV.join(' ')
-    if user_source_code.empty?
+
+  private def create_callable
+    if user_source_code.empty? && (! options.noop)
       STDERR.puts "No source code provided.  Use -h to display help."
       exit(-1)
     end
 
-    requires.each { |r| require(r) }
-    load_global_config_if_exists
-    loads.each { |file| load(file) }
+    eval("Proc.new { #{user_source_code} }")
+  end
 
-    callable = eval("Proc.new { #{user_source_code} }")
 
-    actions = {
+  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) }
-    }
-
-    # 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
-
-    def $RC.i; count end  # `i` aliases `count` so you can more concisely get the count in your user code
+    }[mode]
+  end
 
-    actions[input_mode].() unless self.noop
 
-    if log_format != :none
+  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
-end
 
 
-def input_parser
-  if @input_parser.nil?
-    require_format_require(input_format)
-    @input_parser = input_parsers[input_format]
+  # 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
-  @input_parser
-end
 
 
-def output_formatter
-  if @output_formatter.nil?
-    require_format_require(output_format)
-    @output_formatter = formatters[output_format]
-  end
-  @output_formatter
-end
+  # This class' entry point.
+  def call
+
+    prepend_environment_options
+    parse_command_line
 
+    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
+
+    init_rexe_context
+    init_parser_and_formatters
 
-def log_formatter
-  if @log_formatter.nil?
-    require_format_require(log_format)
-    @log_formatter = formatters[log_format]
+    # 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
   end
-  @log_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__))
-if called_as_script
-  Bundler.with_clean_env { Rexe.new.call }
-end
+Bundler.with_clean_env { Rexe.new.call }