rbcli 0.3.3 → 0.4.0

data/lib/rbcli/components/logger/logger.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+%w(logger json colorize).each { |req| require req }
+require_relative 'lolcat/lol'
+
+# noinspection RubyClassVariableUsageInspection
+class Rbcli::Logger
+  EXECUTABLE ||= File.basename($0).gsub(/\.[^.]+$/, '')
+  @max_prog_len = 0
+  @original_formatter = Logger::Formatter.new
+  @@formatters = {
+    display: Proc.new { |severity, _datetime, _progname, msg|
+      severity == 'INFO' ? msg : "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{msg}"
+    },
+    simple: Proc.new { |severity, _datetime, progname, msg|
+      @max_prog_len = (@max_prog_len > progname.length) ? @max_prog_len : progname.length unless progname.nil?
+      "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{progname || (' ' * @max_prog_len)} || #{msg}"
+    },
+    full: Proc.new { |severity, datetime, progname, msg|
+      @max_prog_len = (@max_prog_len > progname.length) ? @max_prog_len : progname.length unless progname.nil?
+      "#{datetime.strftime("%Y-%m-%d %H:%M:%S.%6N")} || #{EXECUTABLE} || #{progname || (' ' * @max_prog_len)} || #{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{msg}"
+    },
+    apache: Proc.new { |severity, datetime, progname, msg|
+      "[#{datetime.strftime("%a %b %d %H:%M:%S.%6N %Y")}] [#{severity}] [#{EXECUTABLE}] [#{progname}] #{msg.gsub(/\e\[([;\d]+)?m/, '')}"
+    },
+    json: Proc.new { |severity, datetime, progname, msg|
+      { timestamp: datetime.strftime("%Y-%m-%d %H:%M:%S.%N"), severity: severity, application: EXECUTABLE, module: progname, message: msg.gsub(/\e\[([;\d]+)?m/, '') }.to_json
+    },
+    ruby: Proc.new { |severity, datetime, progname, msg|
+      @original_formatter.call(severity, datetime, progname, msg).chomp
+    },
+    lolcat: Proc.new { |severity, _datetime, _progname, msg|
+      "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{Lol.makestr(msg, { spread: 3, freq: 0.1, slope: 4, invert: false, truecolor: true })}"
+    }
+  }
+
+  def self.formats
+    @@formatters.keys
+  end
+
+  def initialize(target: STDOUT, level: :info, format: :display)
+    self.target(target)
+    self.level(level)
+    self.format(format)
+  end
+
+  def target target
+    @logger = Logger.new(target_select(target))
+    @logger.formatter = Proc.new { |severity, datetime, progname, msg|
+      msg = msg.to_s unless msg.is_a?(String)
+      msg.lines.map { |line| @@formatters[@format].call(severity, datetime, progname, line.chomp) }.join("\n") + "\n"
+    }
+  end
+
+  def level slug = nil
+    return @logger.level if slug.nil?
+    @logger.level = logger_level(slug)
+  end
+
+  def format slug = nil
+    return @format if slug.nil?
+    @format = slug if @@formatters.key?(slug)
+  end
+
+  def add_format slug, prok
+    @@formatters[slug] = prok
+  end
+
+  def add level, message, progname = nil, &block
+    @logger.add(logger_level(level), message, progname, &block)
+  end
+
+  def debug message, progname = nil, &block
+    self.add(Logger::DEBUG, message, progname, &block)
+  end
+
+  def info message, progname = nil, &block
+    self.add(Logger::INFO, message, progname, &block)
+  end
+
+  def warn message, progname = nil, &block
+    self.add(Logger::WARN, message, progname, &block)
+  end
+
+  def error message, progname = nil, &block
+    self.add(Logger::ERROR, message, progname, &block)
+  end
+
+  def fatal message, progname = nil, &block
+    self.add(Logger::FATAL, message, progname, &block)
+  end
+
+  def unknown message, progname = nil, &block
+    self.add(Logger::UNKNOWN, message, progname, &block)
+  end
+
+  %w(debug, info, warn, error, fatal, unknown).each do |l|
+    self.define_method(l.to_sym) do |message, progname = nil, &block|
+      self.send(:add, l.to_sym, message, progname, &block)
+    end
+  end
+
+  private
+
+  def self.colorlevel level
+    level.colorize(
+      {
+        'DEBUG' => :blue,
+        'INFO' => :green,
+        'WARN' => :yellow,
+        'ERROR' => :red,
+        'FATAL' => { color: :light_red, mode: :bold },
+        'ANY' => :cyan
+      }[level.to_s.upcase] || :default)
+  end
+
+  def target_select slug
+    {
+      stdout: STDOUT,
+      stderr: STDERR
+    }[slug] || slug
+  end
+
+  def logger_level slug
+    if slug.is_a?(String) || slug.is_a?(Symbol)
+      {
+        debug: Logger::DEBUG,
+        info: Logger::INFO,
+        warn: Logger::WARN,
+        error: Logger::ERROR,
+        fatal: Logger::FATAL,
+        unknown: Logger::UNKNOWN,
+        any: -1
+      }[slug.to_s.downcase.to_sym] || Logger::UNKNOWN
+    else
+      slug
+    end
+  end
+end
+
+module Rbcli
+  @logger = nil
+
+  def self.start_logger target: STDOUT, level: :info, format: :display
+    @logger = Rbcli::Logger.new(target: target, level: level, format: format)
+  end
+
+  def self.log
+    self.start_logger if @logger.nil?
+    @logger
+  end
+end

data/lib/rbcli/components/logger/lolcat/lol.rb

@@ -0,0 +1,71 @@
+# This file was obtained and modified from: https://github.com/busyloop/lolcat/blob/master/lib/lolcat/lol.rb
+
+# Copyright (c) 2016, moe@busyloop.net
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of the lolcat nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'paint'
+
+module Lol
+  ANSI_ESCAPE = /((?:\e(?:[ -\/]+.|[\]PX^_][^\a\e]*|\[[0-?]*.|.))*)(.?)/m
+
+  @os = 0
+  @paint_init = false
+
+  def self.makestr(str, opts = {})
+    @os = rand(256) unless @paint_init
+    set_mode(opts[:truecolor]) unless @paint_init
+
+    result = ''
+    filtered = str.scan(ANSI_ESCAPE)
+    filtered.each_with_index do |c, i|
+      # color = rainbow(opts[:freq], @os + i / opts[:spread])
+      color = rainbow(opts[:freq], (@os + i) / opts[:spread])
+      if opts[:invert] then
+        result += c[0] + Paint.color(nil, color) + c[1] + "\e[49m"
+      else
+        result += c[0] + Paint.color(color) + c[1] + "\e[39m"
+      end
+    end
+    @os += opts[:slope]
+    result
+  end
+
+  private
+
+  def self.set_mode(truecolor)
+    # @paint_mode_detected = Paint.mode
+    @paint_mode_detected = %w[truecolor 24bit].include?(ENV['COLORTERM']) ? 0xffffff : 256
+    Paint.mode = truecolor ? 0xffffff : @paint_mode_detected
+    STDERR.puts "DEBUG: Paint.mode = #{Paint.mode} (detected: #{@paint_mode_detected})" if ENV['LOLCAT_DEBUG']
+    @paint_init = true
+  end
+
+  def self.rainbow(freq, i)
+    red = Math.sin(freq * i + 0) * 127 + 128
+    green = Math.sin(freq * i + 2 * Math::PI / 3) * 127 + 128
+    blue = Math.sin(freq * i + 4 * Math::PI / 3) * 127 + 128
+    "#%02X%02X%02X" % [red, green, blue]
+  end
+end

data/lib/rbcli/components/logger/template.rb.erb

@@ -0,0 +1,40 @@
+Rbcli::Configurate.logger do
+  <%- if @showdocs -%>
+  ##### Logger (Optional) #####
+  # The Rbcli logger is a wrapper around the standard Ruby `Logger` library
+  # It is recommended that - unless you want to use specialized output libraries (such as ncurses) - that all
+  #    of your application output is directed through the logger. This will allow for easy formatting and redirection
+  #    no matter how your application is run.
+  #
+  # Valid targets are: :stdout, :stderr, "/path/to/a/file", or an IO or StringIO object   (Default: :stdout)
+  # Valid levels are: :debug, :info, :warn, :error, :fatal, :unknown, :any                (Default: :info)
+  # Valid formats are: :display, :simple, :full, :ruby, :json, :apache, :lolcat           (Default: :display)
+  #
+  # The first three formats are designed to cover most use cases:
+  #   display:   For display on a terminal, with user interaction
+  #   simple:    For display on a terminal, for a developer
+  #   full:      For logging to a file, or using log collection software
+  # The next three are for specialized integrations in case you already have log collection configured:
+  #   ruby:      Default ruby logger format
+  #   json:      Each line is a JSON object
+  #   apache:    Follows the standard Apache log format
+  # As for :lolcat... if you can't guess what it does then give it a shot
+  <%- end -%>
+  logger target: :stdout, level: :info, format: :display
+  <%- if @showdocs -%>
+  # Custom formats can also be defined here.
+  # Declaring a format here will not switch to it. However, if
+  # the `format` keyword is used without providing a Proc, it will switch
+  # to that format.
+  #
+  #   Format switch:      format :json
+  #   Format definition:  format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+  #
+  # You can also switch formats mid-execution by calling this method on
+  # the logger object itself.
+  #
+  #   Rbcli.log.format :json
+  #
+  <%- end -%>
+  # format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+end

data/lib/rbcli/components/parser/component.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+module Rbcli::Configurate::Cli
+  include Rbcli::Configurable
+
+  @defaults = {
+    appinfo: {
+      appname: EXECUTABLE,
+      version: nil,
+      author: nil,
+      email: nil,
+      copyright_year: nil,
+      license: nil,
+      helptext: nil
+    }
+  }
+
+  @defaults.keys.each do |namespace|
+    @defaults[namespace].each do |key, default|
+      Rbcli::Warehouse.set(key, default, namespace)
+      self.define_singleton_method(key) do |value|
+        Rbcli::Warehouse.set(key, value, namespace)
+      end
+    end
+  end
+
+  def self.opt * args
+    Rbcli::Parser.add_opt *args
+  end
+end

data/lib/rbcli/{util → components/parser/optimist}/optimist.rb

@@ -66,7 +66,7 @@ module Optimist
       else
         lookup = type.to_sym
       end
-      raise ArgumentError, "Unsupported argument type '#{type}', registry lookup '#{lookup}'" unless @registry.has_key?(lookup)
+      raise ArgumentError, "Unsupported argument type '#{type}', registry lookup '#{lookup}'" unless @registry.key?(lookup)
       return @registry[lookup].new
     end
 
@@ -116,6 +116,7 @@ module Optimist
     ## [+:default+] Set the default value for an argument. Without a default value, the hash returned by #parse (and thus Optimist::options) will have a +nil+ value for this key unless the argument is given on the commandline. The argument type is derived automatically from the class of the default value given, so specifying a +:type+ is not necessary if a +:default+ is given. (But see below for an important caveat when +:multi+: is specified too.) If the argument is a flag, and the default is set to +true+, then if it is specified on the the commandline the value will be +false+.
     ## [+:required+] If set to +true+, the argument must be provided on the commandline.
     ## [+:multi+] If set to +true+, allows multiple occurrences of the option on the commandline. Otherwise, only a single instance of the option is allowed. (Note that this is different from taking multiple parameters. See below.)
+    ## [+:permitted+] Specify an Array of permitted values for an option. If the user provides a value outside this list, an error is thrown.
     ##
     ## Note that there are two types of argument multiplicity: an argument
     ## can take multiple values, e.g. "--arg 1 2 3". An argument can also
@@ -184,6 +185,7 @@ module Optimist
     def banner(s)
       @order << [:text, s]
     end
+
     alias_method :text, :banner
 
     ## Marks two (or more!) options as requiring each other. Only handles
@@ -242,7 +244,7 @@ module Optimist
       vals = {}
       required = {}
 
-      opt :version, "Print version and exit" if @version && ! (@specs[:version] || @long["version"])
+      opt :version, "Print version and exit" if @version && !(@specs[:version] || @long["version"])
       opt :help, "Show this message" unless @specs[:help] || @long["help"]
 
       @specs.each do |sym, opts|
@@ -265,9 +267,9 @@ module Optimist
                               end
 
         sym = case arg
-              when /^-([^-])$/      then @short[$1]
-              when /^--([^-]\S*)$/  then @long[$1] || @long["no-#{$1}"]
-              else                       raise CommandlineError, "invalid argument syntax: '#{arg}'"
+              when /^-([^-])$/ then @short[$1]
+              when /^--([^-]\S*)$/ then @long[$1] || @long["no-#{$1}"]
+              else raise CommandlineError, "invalid argument syntax: '#{arg}'"
               end
 
         sym = nil if arg =~ /--no-/ # explicitly invalidate --no-no- arguments
@@ -294,10 +296,10 @@ module Optimist
 
         unless params.empty?
           if @specs[sym].single_arg?
-            given_args[sym][:params] << params[0, 1]  # take the first parameter
+            given_args[sym][:params] << params[0, 1] # take the first parameter
             num_params_taken = 1
           elsif @specs[sym].multi_arg?
-            given_args[sym][:params] << params        # take all the parameters
+            given_args[sym][:params] << params # take all the parameters
             num_params_taken = params.size
           end
         end
@@ -348,13 +350,14 @@ module Optimist
         vals[sym] = opts.parse(params, negative_given)
 
         if opts.single_arg?
-          if opts.multi?        # multiple options, each with a single parameter
+          if opts.multi? # multiple options, each with a single parameter
             vals[sym] = vals[sym].map { |p| p[0] }
-          else                  # single parameter
+          else
+            # single parameter
             vals[sym] = vals[sym][0][0]
           end
         elsif opts.multi_arg? && !opts.multi?
-          vals[sym] = vals[sym][0]  # single option, with multiple parameters
+          vals[sym] = vals[sym][0] # single option, with multiple parameters
         end
         # else: multiple options, with multiple parameters
 
@@ -372,6 +375,7 @@ module Optimist
           self[m] || self[m.to_s]
         end
       end
+
       vals
     end
 
@@ -429,9 +433,11 @@ module Optimist
     rescue Errno::ENOENT
       80
     end
+
     private :legacy_width
 
-    def wrap(str, opts = {}) # :nodoc:
+    def wrap(str, opts = {})
+      # :nodoc:
       if str == ""
         [""]
       else
@@ -587,7 +593,10 @@ module Optimist
     ## instance_eval but with ability to handle block arguments
     ## thanks to _why: http://redhanded.hobix.com/inspect/aBlockCostume.html
     def cloaker(&b)
-      (class << self; self; end).class_eval do
+      (
+        class << self
+          self;
+        end).class_eval do
         define_method :cloaker_, &b
         meth = instance_method :cloaker_
         remove_method :cloaker_
@@ -621,33 +630,55 @@ module Optimist
     end
 
     ## Indicates a flag option, which is an option without an argument
-    def flag? ; false ; end
+    def flag?
+      false;
+    end
+
     def single_arg?
       !self.multi_arg? && !self.flag?
     end
 
-    def multi ; @multi_given ; end
+    def multi
+      @multi_given;
+    end
+
     alias multi? multi
 
     ## Indicates that this is a multivalued (Array type) argument
-    def multi_arg? ; false ; end
+    def multi_arg?
+      false;
+    end
+
     ## note: Option-Types with both multi_arg? and flag? false are single-parameter (normal) options.
 
-    def array_default? ; self.default.kind_of?(Array) ; end
+    def array_default?
+      self.default.kind_of?(Array);
+    end
 
-    def short? ; short && short != :none ; end
+    def short?
+      short && short != :none;
+    end
+
+    def callback
+      opts(:callback);
+    end
 
-    def callback ; opts(:callback) ; end
-    def desc ; opts(:desc) ; end
+    def desc
+      opts(:desc);
+    end
 
-    def required? ; opts(:required) ; end
+    def required?
+      opts(:required);
+    end
 
     def parse(_paramlist, _neg_given)
       raise NotImplementedError, "parse must be overridden for newly registered type"
     end
 
     # provide type-format string.  default to empty, but user should probably override it
-    def type_format ; "" ; end
+    def type_format
+      "";
+    end
 
     def educate
       (short? ? "-#{short}, " : "    ") + "--#{long}" + type_format + (flag? && default ? ", --no-#{long}" : "")
@@ -664,9 +695,9 @@ module Optimist
     ## Generate the default value string for the educate line
     private def default_description_str str
       default_s = case default
-                  when $stdout   then '<stdout>'
-                  when $stdin    then '<stdin>'
-                  when $stderr   then '<stderr>'
+                  when $stdout then '<stdout>'
+                  when $stdin then '<stdin>'
+                  when $stderr then '<stderr>'
                   when Array
                     default.join(', ')
                   else
@@ -680,9 +711,9 @@ module Optimist
     private def permitted_description_str str
       permitted_s = permitted.map do |p|
         case p
-        when $stdout   then '<stdout>'
-        when $stdin    then '<stdin>'
-        when $stderr   then '<stderr>'
+        when $stdout then '<stdout>'
+        when $stdin then '<stdin>'
+        when $stderr then '<stderr>'
         else
           p.to_s
         end
@@ -705,7 +736,7 @@ module Optimist
     # to +Optimist::opt+.  This is trickier in Optimist, than other cmdline
     # parsers (e.g. Slop) because we allow the +default:+ to be able to
     # set the option's type.
-    def self.create(name, desc="", opts={}, settings={})
+    def self.create(name, desc = "", opts = {}, settings = {})
 
       opttype = Optimist::Parser.registry_getopttype(opts[:type])
       opttype_from_default = get_klass_from_default(opts, opttype)
@@ -775,17 +806,17 @@ module Optimist
       lopt = lopt ? lopt.to_s : name.to_s.gsub("_", "-")
       lopt = case lopt
              when /^--([^-].*)$/ then $1
-             when /^[^-]/        then lopt
-             else                     raise ArgumentError, "invalid long option name #{lopt.inspect}"
+             when /^[^-]/ then lopt
+             else raise ArgumentError, "invalid long option name #{lopt.inspect}"
              end
     end
 
     def self.handle_short_opt(sopt)
       sopt = sopt.to_s if sopt && sopt != :none
       sopt = case sopt
-             when /^-(.)$/          then $1
+             when /^-(.)$/ then $1
              when nil, :none, /^.$/ then sopt
-             else                   raise ArgumentError, "invalid short option name '#{sopt.inspect}'"
+             else raise ArgumentError, "invalid short option name '#{sopt.inspect}'"
              end
 
       if sopt
@@ -799,11 +830,16 @@ module Optimist
   # Flag option.  Has no arguments. Can be negated with "no-".
   class BooleanOption < Option
     register_alias :flag, :bool, :boolean, :trueclass, :falseclass
+
     def initialize
       super()
       @default = false
     end
-    def flag? ; true ; end
+
+    def flag?
+      true;
+    end
+
     def parse(_paramlist, neg_given)
       return _paramlist[0] if @multi_given
       return(self.name.to_s =~ /^no_/ ? neg_given : !neg_given)
@@ -813,7 +849,11 @@ module Optimist
   # Floating point number option class.
   class FloatOption < Option
     register_alias :float, :double
-    def type_format ; "=<f>" ; end
+
+    def type_format
+      "=<f>";
+    end
+
     def parse(paramlist, _neg_given)
       paramlist.map do |pg|
         pg.map do |param|
@@ -827,7 +867,11 @@ module Optimist
   # Integer number option class.
   class IntegerOption < Option
     register_alias :int, :integer, :fixnum
-    def type_format ; "=<i>" ; end
+
+    def type_format
+      "=<i>";
+    end
+
     def parse(paramlist, _neg_given)
       paramlist.map do |pg|
         pg.map do |param|
@@ -843,7 +887,11 @@ module Optimist
   # in the case of file-paths given to it.
   class IOOption < Option
     register_alias :io
-    def type_format ; "=<filename/uri>" ; end
+
+    def type_format
+      "=<filename/uri>";
+    end
+
     def parse(paramlist, _neg_given)
       paramlist.map do |pg|
         pg.map do |param|
@@ -865,7 +913,11 @@ module Optimist
   # Option class for handling Strings.
   class StringOption < Option
     register_alias :string
-    def type_format ; "=<s>" ; end
+
+    def type_format
+      "=<s>";
+    end
+
     def parse(paramlist, _neg_given)
       paramlist.map { |pg| pg.map(&:to_s) }
     end
@@ -874,7 +926,11 @@ module Optimist
   # Option for dates.  Uses Chronic if it exists.
   class DateOption < Option
     register_alias :date
-    def type_format ; "=<date>" ; end
+
+    def type_format
+      "=<date>";
+    end
+
     def parse(paramlist, _neg_given)
       paramlist.map do |pg|
         pg.map do |param|
@@ -903,36 +959,66 @@ module Optimist
   # Option class for handling multiple Integers
   class IntegerArrayOption < IntegerOption
     register_alias :fixnums, :ints, :integers
-    def type_format ; "=<i+>" ; end
-    def multi_arg? ; true ; end
+
+    def type_format
+      "=<i+>";
+    end
+
+    def multi_arg?
+      true;
+    end
   end
 
   # Option class for handling multiple Floats
   class FloatArrayOption < FloatOption
     register_alias :doubles, :floats
-    def type_format ; "=<f+>" ; end
-    def multi_arg? ; true ; end
+
+    def type_format
+      "=<f+>";
+    end
+
+    def multi_arg?
+      true;
+    end
   end
 
   # Option class for handling multiple Strings
   class StringArrayOption < StringOption
     register_alias :strings
-    def type_format ; "=<s+>" ; end
-    def multi_arg? ; true ; end
+
+    def type_format
+      "=<s+>";
+    end
+
+    def multi_arg?
+      true;
+    end
   end
 
   # Option class for handling multiple dates
   class DateArrayOption < DateOption
     register_alias :dates
-    def type_format ; "=<date+>" ; end
-    def multi_arg? ; true ; end
+
+    def type_format
+      "=<date+>";
+    end
+
+    def multi_arg?
+      true;
+    end
   end
 
   # Option class for handling Files/URLs via 'open'
   class IOArrayOption < IOOption
     register_alias :ios
-    def type_format ; "=<filename/uri+>" ; end
-    def multi_arg? ; true ; end
+
+    def type_format
+      "=<filename/uri+>";
+    end
+
+    def multi_arg?
+      true;
+    end
   end
 
   ## The easy, syntactic-sugary entry method into Optimist. Creates a Parser,