unimatrix-cli 2.2.0

data/lib/unimatrix_cli/zephyrus/transcribing/configuration_command.rb

@@ -0,0 +1,55 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Transcribing
+      class ConfigurationCommand < Command
+
+        option :key, "The key for an input", type: :string, required: true
+
+        synopsis "Display transcribing configuration for an input"
+
+        def execute
+          response = transcribing_configuration_request
+          if response[ 'outputs' ].nil?
+            write( 
+              message: "Configuration could not be found: #{ response.inspect }",
+              error: true
+            )
+          else
+            response[ 'outputs' ].each do | output | 
+              write( message: parse_configuration_output( output ) )
+            end
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def transcribing_configuration_request
+          endpoint = "#{ Configuration.default_config[ 'zephyrus_url' ] }/" +
+            "transcribing/configuration?key=#{ @options[ :key ] }"
+
+          # Unimatrix SDK cannot handle Zephyrus configuration responses
+          make_request( endpoint, 'Get' )
+        end
+
+        private; def parse_configuration_output( output )
+          output = output.map do | key, value |
+            if key == "rendition"
+              renditions = value.map { | rendition | parse_rendition( rendition ) }.join
+              "rendition:\n*\n#{ renditions }"
+            else
+              "#{ key }: #{ value }\n"
+            end
+          end
+          output << "\n"
+        end
+
+        private; def parse_rendition( rendition )
+          rendition = rendition.map do | key, value |
+            "#{ key }: #{ value }\n"
+          end
+          rendition << "*\n"
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/zephyrus/transmutation/configuration_command.rb

@@ -0,0 +1,55 @@
+module UnimatrixCLI
+  module Zephyrus
+    module Transmutation
+      class ConfigurationCommand < Command
+
+        option :key, "The key for an input", type: :string, required: true
+
+        synopsis "Display transmutation configuration for an input"
+
+        def execute
+          response = transmutation_configuration_request
+          if response[ 'outputs' ].nil?
+            write( 
+              message: "Configuration could not be found: #{ response.inspect }",
+              error: true
+            )
+          else
+            response[ 'outputs' ].each do | output | 
+              write( message: parse_configuration_output( output ) )
+            end
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        private; def transmutation_configuration_request
+          endpoint = "#{ Configuration.default_config[ 'zephyrus_url' ] }/" +
+            "transmutation/onfiguration?key=#{ @options[ :key ] }"
+
+          # Unimatrix SDK cannot handle Zephyrus configuration responses
+          make_request( endpoint, 'Get' )
+        end
+
+        private; def parse_configuration_output( output )
+          output = output.map do | key, value |
+            if key == "rendition"
+              renditions = value.map { | rendition | parse_rendition( rendition ) }.join
+              "rendition:\n*\n#{ renditions }"
+            else
+              "#{ key }: #{ value }\n"
+            end
+          end
+          output << "\n"
+        end
+
+        private; def parse_rendition( rendition )
+          rendition = rendition.map do | key, value |
+            "#{ key }: #{ value }\n"
+          end
+          rendition << "*\n"
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_parser.rb

@@ -0,0 +1,796 @@
+# Modified from trollop commandline processing library 2.1.2
+# https://github.com/ManageIQ/trollop
+
+require 'date'
+
+module UnimatrixParser
+
+  #----------------------------------------------------------------------------
+  # Class Methods
+
+  module ClassMethods
+    def option( name, description = "", options = {} ) 
+      option = Option.new( name, description, options )
+      @options = [] if @options.nil?
+      @options << option
+    end
+
+    def synopsis( synopsis = nil )
+      @synopsis = synopsis
+    end
+
+    def stop_on_unknown
+      @stop_on_unknown = true
+    end
+
+    def educate_if_empty
+      if ARGV.empty?
+        parser = initialize_parser
+        parser.educate
+        exit
+      end
+    end
+
+    def with_standard_exception_handling( parser )
+      yield
+    rescue CommandlineError => error
+      parser.die( error.message, nil, error.error_code )
+    rescue HelpNeeded
+      parser.educate
+      exit
+    end
+
+    def options
+      parser = initialize_parser
+      with_standard_exception_handling( parser ) do 
+        parser.parse( ARGV )
+      end
+    end
+
+    private; def initialize_parser
+      option :help, "Display this help message", type: :string
+      parser = Parser.new
+      parser.options( @options )
+      parser.synopsis( @synopsis )
+      parser.stop_on_unknown if @stop_on_unknown
+      parser
+    end
+  end
+
+  def self.included( base )
+    base.extend( ClassMethods )
+  end
+
+  #----------------------------------------------------------------------------
+  # Error Classes
+
+  class CommandlineError < StandardError
+    attr_reader :error_code
+
+    def initialize( message, error_code = nil )
+      super( message )
+      @error_code = error_code
+    end
+  end
+
+  class HelpNeeded < StandardError; end
+
+  #----------------------------------------------------------------------------
+  # Option Class
+
+  class Option
+    FLAG_TYPES = [ :flag, :bool, :boolean ]
+    SINGLE_ARG_TYPES = [ :int, :integer, :string, :double, :float, :io, :date ]
+    MULTI_ARG_TYPES = [ :ints, :integers, :strings, :doubles, :floats, :ios, :dates ]
+    TYPES = FLAG_TYPES + SINGLE_ARG_TYPES + MULTI_ARG_TYPES
+    INVALID_SHORT_ARG_REGEX = /[\d-]/
+
+    attr_accessor :name, :options
+
+    def initialize( name, description, options )
+      options[ :description ] = description
+      options[ :type ] = normalize_type( options[ :type ] )
+
+      type_from_default = disambiguate_and_set_type_from_default( options )
+
+      if options[ :type ] && type_from_default && options[ :type ] != type_from_default
+        raise ArgumentError, ":type specification and default type don't match " +
+          "(default type is #{ type_from_default })"
+      end
+
+      options[ :type ] = options[ :type ] || type_from_default || :flag
+      options[ :long ] = set_long( options[ :long ], name )
+      options[ :short ] = set_short( options[ :short ] )
+
+      if options[ :short ] && options[ :short ] =~ INVALID_SHORT_ARG_REGEX
+        raise ArgumentError, "a short option name can't be a number or a dash"
+      end
+
+      options[ :default ] = false if options[ :type ] == :flag && options[ :default ].nil?
+
+      if options[ :default ] && options[ :multi ] && !options[ :default ].kind_of?( Array )
+        options[ :default ] = [ options[ :default ] ] 
+      end
+
+      options[ :multi ] ||= false
+
+      self.name = name
+      self.options = options
+    end
+
+    #----------------------------------------------------------------------------
+    # Option Methods
+
+    def key?( name )
+      options.key?( name )
+    end
+
+    def type
+      options[ :type ]
+    end
+    
+    def flag?
+      type == :flag
+    end
+
+    def single_arg?
+      SINGLE_ARG_TYPES.include?( type )
+    end
+
+    def multi 
+      options[ :multi ]
+    end
+    
+    alias multi? multi
+
+    def multi_arg?
+      MULTI_ARG_TYPES.include?( type )
+    end
+
+    def default
+      options[ :default ]
+    end
+    
+    def array_default?
+      options[ :default ].kind_of?( Array )
+    end
+
+    def short
+      options[ :short ]
+    end
+    
+    def short?
+      short && short != :none
+    end
+    
+    def short=( value )
+      options[ :short ] = value
+    end
+    
+    def long
+      options[ :long ]
+    end
+    
+    def description
+      options[ :description ]
+    end
+
+    def required?
+      options[ :required ]
+    end
+
+    #----------------------------------------------------------------------------
+    # Private Option Methods
+
+    private; def normalize_type( type )
+      case type
+        when :boolean, :bool then :flag
+        when :integer        then :int
+        when :integers       then :ints
+        when :double         then :float
+        when :doubles        then :floats
+        when Class
+          case type.name
+            when 'TrueClass',
+                 'FalseClass'  then :flag
+            when 'String'      then :string
+            when 'Integer'     then :int
+            when 'Float'       then :float
+            when 'IO'          then :io
+            when 'Date'        then :date
+            else
+              raise ArgumentError, "unsupported argument type '#{ type.class.name }'"
+          end
+        when nil             then nil
+        else
+          raise ArgumentError, "unsupported argument type " +
+            "'#{ type }'" unless TYPES.include?( type )
+          type
+      end
+    end
+
+    private; def disambiguate_and_set_type_from_default( options )
+      disambiguated_default = if options[ :multi ] && 
+                                 options[ :default ].kind_of?( Array ) && 
+                                 !options[ :type ]
+        options[ :default ].first
+      else
+        options[ :default ]
+      end
+
+      type_from_default =
+      case disambiguated_default
+        when Integer     then :int
+        when Numeric     then :float
+        when TrueClass,
+             FalseClass  then :flag
+        when String      then :string
+        when IO          then :io
+        when Date        then :date
+        when Array
+          if options[ :default ].empty?
+            if options[ :type ]
+              unless MULTI_ARG_TYPES.include?( options[ :type ] )
+                raise ArgumentError, "multiple argument type must be plural"
+              end
+              nil
+            else
+              raise ArgumentError, "multiple argument type cannot be deduced " +
+                "from an empty array for '#{ options[ :default ][ 0 ].class.name }'"
+            end
+          else
+            case options[:default][0]
+              when Integer then :ints
+              when Numeric then :floats
+              when String  then :strings
+              when IO      then :ios
+              when Date    then :dates
+              else
+                raise ArgumentError, "unsupported multiple argument type " +
+                  "'#{ options[ :default ][ 0 ].class.name }'"
+            end
+          end
+        when nil           then nil
+        else
+          raise ArgumentError, "unsupported argument type " +
+            "'#{ options[ :default ].class.name }'"
+      end
+    end
+
+    private; def set_long( long, name )
+      long = long ? long.to_s : name.to_s.gsub( "_", "-" )
+      case long
+        when /^--([^-].*)$/ then $1
+        when /^[^-]/        then long
+        else                
+          raise ArgumentError, "invalid long option name #{ long.inspect }"
+      end
+    end
+
+    private; def set_short( short )
+      short = short.to_s if short && short != :none
+      case short
+        when /^-(.)$/          then $1
+        when nil, :none, /^.$/ then short
+        else                   
+          raise ArgumentError, "invalid short option name '#{ short.inspect }'"
+      end
+    end
+  end
+
+  #----------------------------------------------------------------------------
+  # Parser Class
+
+  class Parser
+    INVALID_SHORT_ARG_REGEX = /[\d-]/
+    FLOAT_REGEX = /^-?((\d+(\.\d+)?)|(\.\d+))([eE][-+]?[\d]+)?$/
+    PARAM_REGEX = /^-(-|\.$|[^\d\.])/
+
+    attr_reader :leftovers
+    attr_reader :specs
+    attr_accessor :ignore_invalid_options
+
+    def initialize( *a, &b )
+      @leftovers = []
+      @specs = {}
+      @long = {}
+      @short = {}
+      @order = []
+      @constraints = []
+      @stop_on_unknown = false
+      @synopsis = nil
+
+      cloaker( &b ).bind( self ).call( *a ) if b
+    end
+
+    def options( options = [] )
+      options.each do | option |
+        if @specs.member?( option.name )
+          # raise ArgumentError, "you already have an argument named '#{ option.name }'"
+          options.delete( option ) # ignore duplicate option
+        elsif @long[ option.long ]
+          raise ArgumentError, "long option name #{ option.long.inspect } " +
+            "is already taken; please specify a (different) :long" 
+        elsif @short[ option.short ]
+          raise ArgumentError, "short option name #{ option.short.inspect } " +
+            "is already taken; please specify a (different) :short" 
+        else
+          @long[ option.long ] = option.name
+          @short[ option.short ] = option.name if option.short?
+          @specs[ option.name ] = option
+          @order << [ :option, option.name ]
+        end
+      end
+    end
+
+    def synopsis( synopsis = nil )
+      synopsis ? @synopsis = synopsis : @synopsis
+    end
+
+    def stop_on_unknown
+      @stop_on_unknown = true
+    end
+
+    def depends( *keys )
+      keys.each do | key | 
+        raise ArgumentError, "unknown option '#{ key }'" unless @specs[ key ]
+      end
+      @constraints << [ :depends, keys ]
+    end
+
+    def conflicts( *keys )
+      keys.each do | key | 
+        raise ArgumentError, "unknown option '#{ key }'" unless @specs[ key ]
+      end
+      @constraints << [ :conflicts, keys ]
+    end
+
+    def parse( cmdline = ARGV )
+      values = {}
+      required = {}
+
+      @specs.each do | key, option |
+        required[ key ] = true if option.required?
+        values[ key ] = option.default
+        values[ key ] = [] if option.multi && !option.default
+      end
+
+      resolve_default_short_options!
+
+      given_args = resolve_symbols( cmdline )
+
+      raise HelpNeeded if given_args.include? :help
+
+      @constraints.each do | type, syms |
+        constraint_sym = syms.find { | sym | given_args[ sym ] }
+        next unless constraint_sym
+
+        case type
+          when :depends
+            syms.each do | sym | 
+              unless given_args.include? sym
+                raise CommandlineError, "--#{ @specs[ constraint_sym ].long } " +
+                  "requires --#{ @specs[ sym ].long }" 
+              end
+            end
+          when :conflicts
+            syms.each do | sym | 
+              if given_args.include?( sym ) && ( sym != constraint_sym )
+                raise CommandlineError, "--#{ @specs[ constraint_sym ].long } " +
+                  "conflicts with --#{ @specs[ sym ].long }"
+              end
+            end
+        end
+      end
+
+      required.each do | key, val |
+        unless given_args.include? key
+          raise CommandlineError, "option --#{ @specs[ key ].long } must be specified"
+        end
+      end
+
+      parse_parameters( given_args, values )
+
+      cmdline.clear
+      @leftovers.each { | leftover | cmdline << leftover }
+
+      # allow openstruct-style accessors
+      class << values
+        def method_missing( m, *_args )
+          self[ m ] || self[ m.to_s ]
+        end
+      end
+      values
+    end
+
+    def parse_date_parameter( param, arg )
+      begin
+        require 'chronic'
+        time = Chronic.parse(param)
+      rescue LoadError
+        # chronic is not available
+      end
+      time ? Date.new( time.year, time.month, time.day ) : Date.parse( param )
+      rescue ArgumentError
+      raise CommandlineError, "option '#{ arg }' needs a date"
+    end
+
+    def educate( stream = $stdout )
+      width # hack: calculate it now; otherwise we have to be careful not to
+            # call this unless the cursor's at the beginning of a line.
+      left = {}
+      @specs.each do | name, spec |
+        left[ name ] =
+          ( spec.short? ? "-#{ spec.short }, " : "" ) + "--#{ spec.long }" +
+          case spec.type
+            when :flag    then ""
+            when :int     then "=<i>"
+            when :ints    then "=<i+>"
+            when :string  then "=<s>"
+            when :strings then "=<s+>"
+            when :float   then "=<f>"
+            when :floats  then "=<f+>"
+            when :io      then "=<filename/uri>"
+            when :ios     then "=<filename/uri+>"
+            when :date    then "=<date>"
+            when :dates   then "=<date+>"
+          end +
+          ( spec.flag? && spec.default ? ", --no-#{ spec.long }" : "" )
+      end
+
+      leftcol_width = left.values.map( &:length ).max || 0
+      rightcol_start = leftcol_width + 6
+
+      unless @order.size > 0 && @order.first.first == :text
+        command_name = File.basename( $0 ).gsub( /\.[^.]+$/, '' )
+        stream.puts "#{ @synopsis }\n" if @synopsis
+        stream.puts "Options:"
+      end
+
+      @order.each do | type, option |
+        if type == :text
+          stream.puts wrap( option )
+          next
+        end
+
+        spec = @specs[ option ]
+        stream.printf "  %-#{ leftcol_width }s    ", left[ option ]
+        description = spec.description + begin
+          default_s = case spec.default
+          when $stdout   then "<stdout>"
+          when $stdin    then "<stdin>"
+          when $stderr   then "<stderr>"
+          when Array
+            spec.default.join( ", " )
+          else
+            spec.default.to_s
+          end
+
+          if spec.default
+            if spec.description =~ /\.$/
+              " (Default: #{ default_s })"
+            else
+              " (default: #{ default_s })"
+            end
+          else
+            ""
+          end
+        end
+        stream.puts wrap( 
+          description, 
+          :width => width - rightcol_start - 1, 
+          :prefix => rightcol_start 
+        )
+      end
+    end
+
+    def width
+      @width ||= if $stdout.tty?
+        begin
+          require 'io/console'
+          w = IO.console.winsize.last
+          w.to_i > 0 ? w : 80
+        rescue LoadError, NoMethodError, Errno::ENOTTY, Errno::EBADF, Errno::EINVAL
+          legacy_width
+        end
+      else
+        80
+      end
+    end
+
+    def wrap( str, opts = {} )
+      if str == ""
+        [ "" ]
+      else
+        inner = false
+        str.split( "\n" ).map do | s |
+          line = wrap_line s, opts.merge( :inner => inner )
+          inner = true
+          line
+        end.flatten
+      end
+    end
+
+    def die( arg, message = nil, error_code = nil )
+      if message
+        $stderr.puts "Error: argument --#{ @specs[ arg ].long } #{ message }."
+      else
+        $stderr.puts "Error: #{ arg }."
+      end
+      $stderr.puts
+      educate $stderr
+      exit( error_code || -1 )
+    end
+
+    #----------------------------------------------------------------------------
+    # Private Parser Methods
+
+    private; def resolve_symbols( cmdline )
+      given_args = {}
+      @leftovers = each_arg cmdline do | arg, params |
+        # handle --no- forms
+        arg, negative_given = if arg =~ /^--no-([^-]\S*)$/
+          [ "--#{ $1 }", true ]
+        else
+          [ arg, false ]
+        end
+
+        key = case arg
+          when /^-([^-])$/      then @short[ $1 ]
+          when /^--([^-]\S*)$/  then @long[ $1 ] || @long[ "no-#{ $1 }" ]
+          else                  raise CommandlineError, "invalid argument syntax: '#{ arg }'"
+        end
+
+        key = nil if arg =~ /--no-/ # explicitly invalidate --no-no- arguments
+
+        next nil if ignore_invalid_options && !key
+        raise CommandlineError, "unknown argument '#{ arg }'" unless key
+
+        if given_args.include?( key ) && !@specs[ key ].multi?
+          raise CommandlineError, "option '#{ arg }' specified multiple times"
+        end
+
+        given_args[ key ] ||= {}
+        given_args[ key ][ :arg ] = arg
+        given_args[ key ][ :negative_given ] = negative_given
+        given_args[ key ][ :params ] ||= []
+
+        # the block returns the number of parameters taken
+        num_params_taken = 0
+
+        unless params.empty?
+          if @specs[ key ].single_arg?
+            given_args[ key ][ :params ] << params[ 0, 1 ] # take the first parameter
+            num_params_taken = 1
+          elsif @specs[ key ].multi_arg?
+            given_args[ key ][ :params ] << params         # take all the parameters
+            num_params_taken = params.size
+          end
+        end
+
+        num_params_taken
+      end
+      given_args
+    end
+
+    private; def parse_parameters( given_args, values )
+      given_args.each do | key, given_data |
+        arg, params, negative_given = given_data.values_at :arg, :params, :negative_given
+
+        option = @specs[ key ]
+        if params.empty? && !option.flag?
+          unless option.default
+            raise CommandlineError, "option '#{ arg }' needs a parameter"
+          end
+          params << ( option.array_default? ? option.default.clone : [ option.default ] )
+        end
+
+        # mark argument as specified on the commandline
+        values[ "#{ key }_given".intern ] = true 
+
+        case option.type
+          when :flag
+            values[ key ] = ( key.to_s =~ /^no_/ ? negative_given : !negative_given )
+          when :int, :ints
+            values[ key ] = params.map do | param | 
+              param.map { | p | parse_integer_parameter p, arg }
+            end
+          when :float, :floats
+            values[ key ] = params.map do | param | 
+              param.map { | p | parse_float_parameter p, arg }
+            end
+          when :string, :strings
+            values[ key ] = params.map do | param | 
+              param.map( &:to_s )
+            end
+          when :io, :ios
+            values[ key ] = params.map do | param | 
+              param.map { | p | parse_io_parameter p, arg }
+            end
+          when :date, :dates
+            values[ key ] = params.map do | param | 
+              param.map { | p | parse_date_parameter p, arg }
+            end
+        end
+
+        if option.single_arg?
+          if option.multi?       # multiple options, each with a single parameter
+            values[ key ] = values[ key ].map { | p | p[ 0 ] }
+          else                   # single parameter
+            values[ key ] = values[ key ][ 0 ][ 0 ]
+          end
+        elsif option.multi_arg? && !option.multi?
+          values[ key ] = values[ key ][ 0 ]  # single option, with multiple parameters
+        end
+        # else: multiple options, with multiple parameters
+      end
+    end
+
+    private; def legacy_width
+      # Support for older Rubies where io/console is not available
+      `tput cols`.to_i
+      rescue Errno::ENOENT
+      80
+    end
+
+    private; def each_arg( args )
+      remains = []
+      i = 0
+
+      until i >= args.length
+        # return remains += args[ i..-1 ] if @stop_words.member? args[ i ]
+        case args[ i ]
+          when /^--$/ # arg terminator
+            return remains += args[ ( i + 1 )..-1 ]
+          when /^--(\S+?)=(.*)$/ # long argument with equals
+            num_params_taken = yield "--#{ $1 }", [ $2 ]
+            if num_params_taken.nil?
+              remains << args[ i ]
+              if @stop_on_unknown
+                return remains += args[ i + 1..-1 ]
+              end
+            end
+            i += 1
+          when /^--(\S+)$/ # long argument
+            params = collect_argument_parameters( args, i + 1 )
+            num_params_taken = yield args[ i ], params
+
+            if num_params_taken.nil?
+              remains << args[ i ]
+              if @stop_on_unknown
+                return remains += args[ i + 1..-1 ]
+              end
+            else
+              i += num_params_taken
+            end
+            i += 1
+          when /^-(\S+)$/ # one or more short arguments
+            short_remaining = ""
+            shortargs = $1.split( // )
+            shortargs.each_with_index do | a, j |
+              if j == ( shortargs.length - 1 )
+                params = collect_argument_parameters( args, i + 1 )
+
+                num_params_taken = yield "-#{ a }", params
+                unless num_params_taken
+                  short_remaining << a
+                  if @stop_on_unknown
+                    remains << "-#{ short_remaining }"
+                    return remains += args[ i + 1..-1 ]
+                  end
+                else
+                  i += num_params_taken
+                end
+              else
+                unless yield "-#{ a }", []
+                  short_remaining << a
+                  if @stop_on_unknown
+                    short_remaining += shortargs[ j + 1..-1 ].join
+                    remains << "-#{ short_remaining }"
+                    return remains += args[ i + 1..-1 ]
+                  end
+                end
+              end
+            end
+
+            unless short_remaining.empty?
+              remains << "-#{ short_remaining }"
+            end
+            i += 1
+          else
+            if @stop_on_unknown
+              return remains += args[ i..-1 ]
+            else
+              remains << args[ i ]
+              i += 1
+            end
+        end
+      end
+
+      remains
+    end
+
+    private; def parse_integer_parameter( param, arg )
+      unless param =~ /^-?[\d_]+$/
+        raise CommandlineError, "option '#{ arg }' needs an integer"
+      end
+      param.to_i
+    end
+
+    private; def parse_float_parameter( param, arg )
+      unless param =~ FLOAT_REGEX
+        raise CommandlineError, "option '#{ arg }' needs a floating-point number"
+      end
+      param.to_f
+    end
+
+    private; def parse_io_parameter( param, arg )
+      if param =~ /^(stdin|-)$/i
+        $stdin
+      else
+        require 'open-uri'
+        begin
+          open param
+        rescue SystemCallError => e
+          raise CommandlineError, "file or url for option '#{ arg }' " +
+            "cannot be opened: #{ e.message }"
+        end
+      end
+    end
+
+    private; def collect_argument_parameters( args, start_at )
+      params = []
+      pos = start_at
+      while args[ pos ] && args[ pos ] !~ PARAM_REGEX do
+        params << args[ pos ]
+        pos += 1
+      end
+      params
+    end
+
+    private; def resolve_default_short_options!
+      @order.each do | type, name |
+        option = @specs[ name ]
+        next if type != :option || option.short
+
+        c = option.long.split( // ).find do | d | 
+          d !~ INVALID_SHORT_ARG_REGEX && !@short.member?( d )
+        end
+
+        if c
+          option.short = c
+          @short[ c ] = name
+        end
+      end
+    end
+
+    private; def wrap_line( str, opts = {} )
+      prefix = opts[ :prefix ] || 0
+      width = opts[ :width ] || ( self.width - 1 )
+      start = 0
+      ret = []
+      until start > str.length
+        nextt =
+          if start + width >= str.length
+            str.length
+          else
+            x = str.rindex( /\s/, start + width )
+            x = str.index( /\s/, start ) if x && x < start
+            x || str.length
+          end
+        ret << ( ( ret.empty? && !opts[ :inner ] ) ? "" : " " * prefix ) + str[ start...nextt ]
+        start = nextt + 1
+      end
+      ret
+    end
+
+    private; def cloaker( &b )
+      ( class << self; self; end ).class_eval do
+        define_method :cloaker_, &b
+        meth = instance_method :cloaker_
+        remove_method :cloaker_
+        meth
+      end
+    end
+  end
+end