appl 1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c17ebbb3f574a1d27df9610144f9881c3b8ef910
+  data.tar.gz: 6e68ffdb0dd1e1c227dc371f29e9d93fb7a1abef
+SHA512:
+  metadata.gz: c16e0eb7be520d7eace0ab904c838d61ab3eaa29b34d3f2fda9d5c23b35f03721f244ffb814389399bb6f1a175ba68cdd39a2b9fefb7f4cc7bb4f84ce8dbeef0
+  data.tar.gz: 98cf8b5bde3d91115a0763e0561718f04a99d560134d52448f68384662af9814cad6fdc44a283352e00897cf323fd450e4f1c9e77de7c052f9a75ab7dbc4ae51

data/bin/intar

@@ -0,0 +1,156 @@
+#!/usr/local/bin/ruby
+
+#
+#  intar  --  Interactive Ruby evaluation
+#
+
+require "intar"
+require "appl"
+
+
+class IntarApp < Application
+
+  NAME      = "intar"
+  VERSION   = APPL_VERSION
+  SUMMARY   = "Interactive Ruby"
+  COPYRIGHT = "(C) 2008-2013 Bertram Scharpf <software@bertram-scharpf.de>"
+  LICENSE   = "BSD"
+  AUTHOR    = "Bertram Scharpf <software@bertram-scharpf.de>"
+
+  DESCRIPTION = <<EOT
+Prompt for Ruby statements, evaluate them. This is a replacement
+for "irb". The underlying library may be entered from inside any
+Ruby program.
+
+Example:
+
+  $ intar -p '%(33 1)c%t%c%> '
+
+EOT
+
+  def quiet!
+    Intar.show = nil
+  end
+  def show= s
+    Intar.show = s.to_i
+  end
+  def prompt= p
+    Intar.prompt = p if p
+  end
+  def bw!
+    Intar.colour = false
+  end
+  def catch_exit!
+    Intar.catch_exit = (Intar.catch_exit||0) + 3
+  end
+  def histall!
+    Intar.histhid = false
+  end
+  def histfile= h
+    Intar.histfile = nil_if_none h
+  end
+  def histmax= m
+    Intar.histmax = (Integer m rescue m.to_i)
+  end
+  def configfile= c
+    @configfile = nil_if_none c
+  end
+
+  define_option "p", :prompt=, "STR",
+                              "prompt - see source code for % escapes"
+  alias_option  "p", "prompt"
+
+  define_option "q", :quiet!,                     "don't show results"
+  alias_option  "q", "quiet"
+
+  define_option "S", :show=, "N", 1,  "show result line limit (0=all)"
+  alias_option  "S", "show"
+
+  define_option "r", :require, "FILE",                  "Ruby require"
+  alias_option  "r", "require"
+
+  define_option "bw", :bw!,                            "black & white"
+
+  define_option "c", :configfile=, "FILE", ".intarrc",
+                                        "config file, NONE means none"
+  alias_option  "c", "configfile"
+
+  define_option "H", :histfile=, "FILE", ".intar_history",
+                                       "history file, NONE means none"
+  alias_option  "H", "histfile"
+
+  define_option "m", :histmax=, "NUM",
+                                     "maximum history entries to save"
+  alias_option  "m", "histmax"
+
+  define_option "A", :histall!,
+                          "pass lines starting with blanks to history"
+  alias_option  "A", "histall"
+
+  define_option "E", :encoding=, "ENC",  "set encoding (like ruby -E)"
+  alias_option  "E", "encoding"
+
+  define_option "x", :catch_exit!,
+                     "On exit exception: Wait 3 seconds for interrupt"
+  alias_option  "x", "catchexit"
+  alias_option  "x", "catch-exit"
+
+  define_option "h", :help,                             "show options"
+  alias_option  "h", "help"
+  define_option "V", :version,                          "show version"
+  alias_option  "V", "version"
+
+  def run
+    # @debug = true      # Only development.
+    read_cfg
+    main = eval "self", TOPLEVEL_BINDING
+    Intar.open main do |i|
+      i.run *(@args.shift @args.length)
+    end
+  end
+
+  private
+
+  def encoding= ei
+    e, i = ei.split ":"
+    Encoding.default_external = e if e and not e.empty?
+    Encoding.default_internal = i if i and not i.empty?
+    [ $stdin, $stdout, $stderr].each do |io|
+      io.set_encoding e, i
+    end
+  end
+
+
+  def read_cfg
+    c = @configfile
+    return unless c
+    unless c[ File::SEPARATOR] or (File.exists? c) then
+      c = File.expand_path c, "~"
+      return unless File.exists? c
+    end
+    r = File.read c
+    r.prepend "$SAFE = 1#$/"
+    Thread.new {
+      begin
+        eval r, TOPLEVEL_BINDING
+      rescue Exception
+        $@.pop 2
+        e = $@.shift
+        puts "#{e}: #$! (#{$!.class})"
+        $@.each { |l| puts "\t#{l}" }
+        raise "Error in config file #{c}"
+      end
+    }.value
+  end
+
+  def nil_if_none var
+    case var
+      when "", "NONE" then nil
+      else                 var
+    end
+  end
+
+end
+
+IntarApp.run
+

data/doc/demoappl

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+#
+#  demoappl  -- Just test the Application class
+#
+
+require "appl"
+
+class DemoAppl < Application
+
+  NAME      = "demoappl"
+  VERSION   = "1.0"
+  SUMMARY   = "Just test the Application class"
+  COPYRIGHT = "(C) 2011 Bertram Scharpf"
+  LICENSE   = "For internal use only"
+  AUTHOR    = "Bertram Scharpf <software@bertram-scharpf.de>"
+
+  DESCRIPTION = <<EOT
+This is an example how to define an Application subclass.
+The program just prints out its parameters.
+
+EOT
+
+  OPTIONS_ENV = "DEMO_OPTS"
+
+  attr_writer :param, :default_param
+  attr_bang :switch, :raise, :debug
+
+  define_option "s", :switch!,                                "dummy switch"
+  alias_option  "s", "switch"
+
+  define_option "p", :param=, "PARAM",                     "dummy parameter"
+  alias_option  "p", "param"
+
+  define_option "d", :default_param=, "PARAM:dddd",
+                                        "dummy parameter with default value"
+  alias_option  "d", "default-param"
+
+  define_option "r", :raise!,                           "raise an exception"
+  alias_option  "r", "raise"
+
+  define_option "g", :debug!,           "lots of ugly debugging information"
+  alias_option  "g", "debug"
+
+  define_option "h", :help,                         "show this options list"
+  alias_option  "h", "help"
+  define_option "V", :version,                    "show version information"
+  alias_option  "V", "version"
+
+  UNKNOWN = "Sorry, unknown option"
+  STOPOPT = "no more options"
+  UNPROCA = "Warning: unprocessed arguments left"
+
+  def run
+    puts inspect
+    raise "stop" if @raise
+    ENV[ OPTIONS_ENV] or
+      puts "Try to set the environment variable #{OPTIONS_ENV}."
+    @args.clear
+  end
+
+end
+
+if false then
+  DemoAppl.run %w(-s -p rrrr qqqq -x -y -z)
+else
+  DemoAppl.run
+end
+

data/lib/appl.rb

@@ -0,0 +1,302 @@
+#
+#  appl.rb  --  Application class
+#
+
+
+class Application
+
+  APPL_VERSION = "1.2".freeze
+
+  OPTIONS_ENV = nil
+
+  STOPOPT = "stop option processing"
+  UNKNOWN = "Unknown option"
+  UNPROCA = "Warning: unprocessed arguments"
+
+  class OptionError < StandardError ; end
+  class Done        < Exception     ; end
+
+  def initialize args = nil
+    @args = args||self.class.cmdline_arguments
+    self.class.each_option { |opt,desc,arg,dfl,act|
+      begin
+        send act, dfl if dfl
+      rescue NoMethodError
+        raise OptionError, "Option action `#{act}' is not defined."
+      end
+    }
+    while @args.first =~ /\A-/ do
+      opt = $'
+      @args.shift
+      if opt =~ /\A-/ then
+        break if !$' or $'.empty?
+        opt = $'
+        if opt =~ /^=/ then opt = $` ; @args.unshift $' end
+        act = self.class.option_act @args, opt, nil
+        send *act
+      else
+        until not opt or opt.empty? do
+          c = opt.slice! 0, 1
+          if opt =~ /^=/ then opt = nil ; @args.unshift $' end
+          act = self.class.option_act @args, c, opt
+          send *act
+        end
+      end
+    end
+  end
+
+  def help
+    c = self.class
+    puts c.version
+    puts
+    puts c::DESCRIPTION
+    puts
+    c.show_options
+    if block_given? then
+      puts
+      yield
+    end
+    raise Done
+  end
+
+  def version
+    self.class.show_version
+    raise Done
+  end
+
+  VERSION = "0"
+  NAME    = "appl"
+  SUMMARY = "Dummy application"
+  DESCRIPTION = <<-EOT
+This base class does nothing by default.
+  EOT
+
+  def run
+  end
+
+  def execute
+    run
+    if @args.any? then
+      u = @args.join " "
+      puts "#{self.class::UNPROCA}: #{u}"
+    end
+    0
+  rescue SignalException
+    raise if @debug
+    self.class.show_message $!.inspect
+    128 + ($!.signo||2)    # Ruby 1.8 returns signo +nil+; assume SIGINT
+  rescue
+    raise if @debug
+    self.class.show_message "Error: #$!", "(#{$!.class})"
+    $!.to_i rescue 1
+  end
+
+  HASH_ORDER = RUBY_VERSION >= "1.9"
+
+  class <<self
+
+    def run args = nil
+      e = execute args
+      exit e
+    end
+
+    def version
+      if self::VERSION =~ %r/\s/ then
+        self::VERSION
+      else
+        "#{self::NAME} #{self::VERSION}  --  #{self::SUMMARY}"
+      end
+    end
+
+    private
+
+    def execute args = nil
+      i = new args
+      i.execute
+    rescue Done
+      0
+    rescue OptionError
+      show_message $!
+      127
+    end
+
+    def inherited sub
+      sub.instance_eval { @options, @aliases = {}, {} }
+    end
+
+    def attr_bang *syms
+      syms.each { |sym|
+        define_method :"#{sym}!" do
+          instance_variable_set :"@#{sym}", true
+        end
+      }
+      nil
+    end
+
+    public
+
+    def define_option opt, *param
+      delete_option opt
+      act = param.shift
+      desc = param.pop
+      arg = param.shift
+      if arg then
+        if param.empty? then
+          arg, dfl = arg.split /:/, 2
+          if dfl =~ /\A:/ then
+            dfl = $'.to_sym
+          end
+        else
+          dfl = param.shift
+        end
+      end
+      d = param.map { |x| "#{x}#$/" }.join
+      desc.insert 0, d
+      @options[ opt.to_s] = [ desc, arg, dfl, act]
+      nil
+    end
+    alias def_option define_option
+
+    def alias_option orig, opt
+      unalias_option opt
+      @aliases[ opt.to_s] = orig.to_s
+      nil
+    end
+
+    def delete_option opt
+      self < Application or return
+      superclass.delete_option opt
+      @options.delete opt
+      @aliases.reject! { |k,v| v == opt }
+      nil
+    end
+
+    def unalias_option opt
+      self < Application or return
+      superclass.unalias_option opt
+      @aliases.delete opt
+      nil
+    end
+
+    protected
+
+    def find_option_act opt
+      self < Application or return
+      @options[ opt] || @options[ @aliases[ opt]] ||
+        (superclass.find_option_act opt)
+    end
+
+    def all_options
+      if self < Application then
+        r = superclass.all_options
+        r.update @options
+      else
+        {}
+      end
+    end
+
+    def all_aliases
+      if self < Application then
+        r = superclass.all_aliases
+        r.update @aliases
+      else
+        {}
+      end
+    end
+
+    def options_desc &block
+      a = Hash.new do |h,k| h[ k] = [] end
+      all_aliases.each { |k,v|
+        a[ v].push k
+      }
+      a.values.each { |v| v.sort! } unless HASH_ORDER
+      each_option { |opt,desc,arg,dfl,|
+        yield opt, arg, dfl, desc
+        a[ opt].each { |l|
+          yield l, nil, nil, nil
+        }
+      }
+      yield "", nil, nil, self::STOPOPT
+    end
+
+    public
+
+    def each_option
+      o = all_options
+      o = o.sort_by { |k,v| k.swapcase } unless HASH_ORDER
+      o.each { |opt,(desc,arg,dfl,act)|
+        case dfl
+          when Symbol then dfl = const_get dfl
+        end
+        yield opt, desc, arg, dfl, act
+      }
+    end
+
+    def option_act args, opt, rest
+      dada = find_option_act opt
+      dada or raise OptionError, "#{self::UNKNOWN}: `#{opt}'."
+      desc, arg, dfl, act = *dada
+      r = [ act]
+      if arg then
+        p = rest.slice! 0, rest.length if rest and not rest.empty?
+        r.push p||args.shift
+      end
+      r
+    end
+
+    def show_options
+      options_desc do |opt,arg,dfl,desc|
+        opt = opt.length == 1 ? "-#{opt}" : "--#{opt}"
+        arg &&= "#{arg}"
+        dfl &&= "[#{dfl}]"
+        arg << dfl if arg && dfl
+        puts "  %-10s  %-12s  %s" % [ opt, arg, desc]
+      end
+    end
+
+    def show_version
+      puts version
+      puts self::COPYRIGHT if const_defined? :COPYRIGHT
+      puts "License: #{self::LICENSE}" if const_defined? :LICENSE
+      a = []
+      a.push   self::AUTHOR  if const_defined? :AUTHOR
+      a.concat self::AUTHORS if const_defined? :AUTHORS
+      if a.any? then
+        a.flatten!
+        a.uniq!
+        j = a.join ", "
+        h = a.length == 1 ? "Author" : "Authors"
+        puts "#{h}: #{j}"
+      end
+    end
+
+    def show_message msg, extra = nil
+      if $stderr.tty? then
+        msg = "\e[31;1m#{msg}\e[m"
+        if extra then
+          extra = "\e[31m#{extra}\e[m"
+        end
+      end
+      if extra then
+        msg = [ msg, extra].join " "
+      end
+      $stderr.puts msg
+    end
+
+    def cmdline_arguments
+      r = []
+      oe = self::OPTIONS_ENV
+      eo = ENV[ oe] if oe
+      if eo then
+        eo.scan /"((?:\\.|[^"])*")|[^" \t]+/ do
+          r.push $1 ? (eval $1) : $&
+        end
+      end
+      r.concat $*
+      r
+    end
+
+  end
+
+end
+

data/lib/intar.rb

@@ -0,0 +1,451 @@
+#
+#  intar.rb  --  Interactive Ruby evaluation
+#
+
+
+=begin rdoc
+
+This could be opened not only by the Intar executable but also
+everywhere inside your Ruby program.
+
+= Example 1
+
+  require "intar"
+
+  Intar.prompt = "str(%(length)i):%03n%> "
+  a = "hello"
+  Intar.run a
+
+
+= Example 2
+
+  require "intar"
+
+  class C
+  end
+
+  class IntarC < Intar
+    @show     = 3
+    @prompt   = "%(33 1)c%t%c%> "
+    @histfile = ".intarc_history"
+
+    class <<self
+      def open
+        super C.new
+      end
+    end
+  end
+
+  IntarC.open do |ia| ia.run end
+
+=end
+
+
+require "readline"
+require "supplement"
+require "supplement/terminal"
+
+
+class Object
+  def empty_binding
+    binding
+  end
+end
+
+class Intar
+
+  class History
+
+    IND = "  "
+    IND_RE = /^#{IND}/
+
+    def initialize filename
+      @filename = filename
+      return unless @filename
+      h = "~" unless @filename.starts_with "./"
+      @filename = File.expand_path @filename, h
+      File.exists? @filename and File.open @filename do |h|
+        c = []
+        h.each { |l|
+          case l
+            when IND_RE then c.push $'
+            else             push c.join.chomp ; c.clear
+          end
+        }
+        push c.join.chomp
+      end
+      @num = Readline::HISTORY.length
+    end
+
+    def finish max
+      return unless @filename
+      @num.times { Readline::HISTORY.shift }
+      File.open @filename, "a" do |h|
+        a = []
+        while (c = Readline::HISTORY.shift) do a.push c end
+        if a.any? then
+          h.puts "# #{Time.now}"
+          a.each { |c|
+            c.each_line { |l| h.puts IND + l }
+            h.puts "-"
+          }
+          i = a.length
+          h.puts "# #{i} #{entry_str i} added"
+        end
+      end
+      n = File.open @filename do |h|
+        h.inject 0 do |i,l| i += 1 if l =~ IND_RE ; i end
+      end
+      i = max - n
+      if i < 0 then
+        f = nil
+        File.open @filename do |h|
+          h.each_line { |l|
+            f.push l if f
+            case l
+              when IND_RE then i += 1
+              else             f ||= [] if i >= 0
+            end
+          }
+        end
+        f and File.open @filename, "w" do |h| h.puts f end
+      end
+    rescue Errno
+      # Forget it if there isn't enough disk space.
+    end
+
+    def push l
+      Readline::HISTORY.push l unless l.empty?
+    end
+
+    private
+
+    def entry_str i
+      i == 1 ? "entry" : "entries"
+    end
+
+  end
+
+  class <<self
+
+    attr_accessor :prompt, :show, :colour
+
+    attr_reader :histfile
+    def histfile= hf
+      @histfile = hf
+      if @history then
+        @history.finish @histmax
+        @history = History.new @histfile
+      end
+    end
+
+    # Maximum number of history entries.
+    attr_accessor :histmax
+
+    # Whether to hide entries starting with whitespace.
+    attr_accessor :histhid
+
+    # Shell prefix and Pipe suffix
+    attr_accessor :sh_pref, :pi_suff
+
+    # Whether <code>Kernel#exit</code> should be caught.
+    attr_accessor :catch_exit
+
+    private
+
+    def inherited sub
+      sub.class_eval {
+        s = superclass
+        @prompt     = s.prompt
+        @show       = s.show
+        @colour     = s.colour
+        @histfile   = s.histfile
+        @histmax    = s.histmax
+        @histhid    = s.histhid
+        @sh_pref    = s.sh_pref
+        @pi_suff    = s.pi_suff
+        @catch_exit = s.catch_exit
+      }
+    end
+
+    def history_file
+      if @history then
+        yield
+      else
+        @history = History.new @histfile
+        begin
+          yield
+        ensure
+          @history.finish @histmax
+          @history = nil
+        end
+      end
+    end
+
+    public
+
+    private :new
+    def open obj
+      history_file do
+        i = new obj
+        yield i
+      end
+    end
+
+    def run obj
+      open obj do |i| i.run end
+    end
+
+    def hist_add l
+      return if @histhid and l == /\A[ \t]+/
+      lst = Readline::HISTORY[-1] if Readline::HISTORY.length > 0
+      @history.push l unless l == lst
+    end
+
+  end
+
+  self.prompt     = "%(32)c%i%c:%1c%03n%c%> "
+  self.show       = 1
+  self.colour     = true
+  self.histfile   = nil
+  self.histmax    = 500
+  self.histhid    = true
+  self.sh_pref    = "."
+  self.pi_suff    = " |"
+  self.catch_exit = nil
+
+  private
+
+  def initialize obj
+    @obj = obj
+    @n = 0
+  end
+
+  OLDSET = <<-EOT
+    _, __, ___ = nil, nil, nil
+    proc { |r,n|
+      Array === __ or __ = []
+      Hash === ___ or ___ = {}
+      unless r.nil? or r.equal? __ or r.equal? ___ then
+        _ = r
+        __.delete r rescue nil
+        __.unshift r
+        ___[ n] = r
+      end
+    }
+  EOT
+
+  autoload :Etc,    "etc"
+  autoload :Socket, "socket"
+
+  def cur_prompt
+    t = Time.now
+    self.class.prompt.gsub /%(?:
+                               \(([^\)]*)\)
+                             |
+                               ([+-]?[0-9]+(?:\.[0-9]+)?)
+                             )?(.)/nx do
+      case $3
+        when "s" then @obj.to_s
+        when "i" then $1.notempty? ? (@obj.send $1) : @obj.inspect
+        when "n" then "%#$2d" % @n
+        when "t" then t.strftime $1||"%X"
+        when "u" then Etc.getpwuid.name
+        when "h" then Socket.gethostname
+        when "w" then cwd_short
+        when "W" then File.basename cwd_short
+        when "c" then (colour *($1 || $2 || "").split.map { |x| x.to_i }).to_s
+        when ">" then Process.uid == 0 ? "#" : ">"
+        when "%" then $3
+        else          $&
+      end
+    end
+  end
+
+  def colour *c
+    if self.class.colour then
+      s = c.map { |i| "%d" % i }.join ";"
+      "\e[#{s}m"
+    end
+  end
+
+  def switchcolour *c
+    s = colour *c
+    print s if s
+  end
+
+  def cwd_short
+    r = Dir.pwd
+    h = Etc.getpwuid.dir
+    r[ 0, h.length] == h and r[ 0, h.length] = "~"
+    r
+  end
+
+  def readline
+    r, @previous = @previous, nil
+    r or @n += 1
+    cp = cur_prompt
+    loop do
+      begin
+        l = Readline.readline r ? "" : cp
+      rescue Interrupt
+        puts "^C  --  #{$!.inspect}"
+        retry
+      end
+      if r then
+        break if l.nil?
+        r << $/ << l
+        break if l.empty?
+      else
+        return if l.nil?
+        next unless l =~ /\S/
+        r = l
+        break unless l =~ /\\+\z/ and $&.length % 2 != 0
+      end
+    end
+    cp.strip!
+    cp.gsub! /\e\[[0-9]*(;[0-9]*)*m/, ""
+    @file = "#{self.class}/#{cp}"
+    self.class.hist_add r
+    r
+  end
+
+  # :stopdoc:
+  ARROW    = "=> "
+  ELLIPSIS = "..."
+  # :startdoc:
+
+  def display r
+    return if r.nil?
+    show = (self.class.show or return)
+    i = r.inspect
+    if show > 0 then
+      siz, = $stdout.winsize
+      siz *= show
+      siz -= ARROW.length
+      if i.length > siz then
+        i.cut! siz-ELLIPSIS.length
+        i << ELLIPSIS
+      end
+    end
+    i.prepend ARROW
+    puts i
+  end
+
+  def pager doit
+    if doit then
+      IO.popen ENV[ "PAGER"]||"more", "w" do |pg|
+        begin
+          stdout = $stdout.dup
+          $stdout.reopen pg
+          yield
+        ensure
+          $stdout.reopen stdout
+        end
+      end
+    else
+      yield
+    end
+  end
+
+  public
+
+  class Exit      < Exception ; end
+  class CmdFailed < Exception ; end
+
+  def run *precmds
+    bind = @obj.empty_binding
+    precmds.each { |l| eval l, bind }
+    oldset = eval OLDSET, bind
+    @cl = eval "caller.length", bind
+    while l = readline do
+      re_sh_pref = /\A#{Regexp.quote self.class.sh_pref}/
+      re_pi_suff = /#{Regexp.quote self.class.pi_suff}\z/
+      switchcolour
+      begin
+        pg = l.slice! re_pi_suff
+        r = pager pg do
+          unless l =~ re_sh_pref then
+            eval l, bind, @file
+          else
+            call_system $', bind
+          end
+        end
+        oldset.call r, @n
+        display r
+      rescue Exit
+        wait_exit and break
+      rescue CmdFailed
+        oldset.call $?, @n
+        switchcolour 33
+        puts "Exit code: #{$?.exitstatus}"
+      rescue LoadError
+        oldset.call $!, @n
+        show_exception
+      rescue ScriptError
+        if l[ $/] then
+          switchcolour 33
+          puts $!
+        else
+          @previous = l
+        end
+      rescue SystemExit
+        break if wait_exit
+        oldset.call $!, @n
+        show_exception
+      rescue Exception
+        oldset.call $!, @n
+        show_exception
+      ensure
+	switchcolour
+      end
+    end
+    puts
+  ensure
+    done
+  end
+
+  protected
+
+  def done
+  end
+
+  private
+
+  def wait_exit
+    c = self.class.catch_exit
+    c and c.times { print "." ; $stdout.flush ; sleep 1 }
+    true
+  rescue Interrupt
+    puts
+  end
+
+  def show_exception
+    unless $!.to_s.empty? then
+      switchcolour 31, 1
+      print $!
+      print " " unless $!.to_s =~ /\s\z/
+    end
+    switchcolour 31, 22
+    puts "(#{$!.class})"
+    switchcolour 33
+    bt = $@.dup
+    if bt.length > @cl then
+      bt.pop @cl
+      bt.push bt.pop[ /(.*:\d+):.*/, 1]
+    end
+    puts bt
+  end
+
+  def call_system l, bind
+    l.strip!
+    raise Exit if l.empty?
+    eot = "EOT0001"
+    eot.succ! while l[ eot]
+    l = eval "<<#{eot}\n#{l}\n#{eot}", bind, @file
+    system l or raise CmdFailed
+    nil
+  end
+
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: appl
+version: !ruby/object:Gem::Version
+  version: '1.2'
+platform: ruby
+authors:
+- Bertram Scharpf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: supplement
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: |
+  A base class for command line applications doing options parsing
+  and generating exit codes.
+email: "<software@bertram-scharpf.de>"
+executables:
+- intar
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/intar
+- doc/demoappl
+- lib/appl.rb
+- lib/intar.rb
+homepage: http://www.bertram-scharpf.de/software/appl
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Just Ruby
+rubyforge_project: NONE
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Easy option parsing
+test_files: []