intar 2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ebb1f8448fc1b1975a50bbc99cac9e601dfc5c8c949fc9c6bb3e2e9ccec5d556
+  data.tar.gz: ac7e7ac5915357dd60db8e958a4c58fc15050c3b04d52746a0d3e3d05d971d98
+SHA512:
+  metadata.gz: 5e983cbc3b2773a4f3fc8297407f59aa56fd5156adaa5af2c2e7657e5e3523f8b16bfa193e5f088e1a5d4b259838f63444b7dea35a564c8133e85969ec055205
+  data.tar.gz: bfeb03f9854a50f9f5c7d1ef7c658bd871a4f0896448009236c27f1125e2c6517e563c84b1c6a294c5289a7588e5f180e348af04b89e2949bcacc721be7fddcc

data/bin/intar

@@ -0,0 +1,145 @@
+#!/usr/local/bin/ruby
+
+#
+#  intar  --  Interactive Ruby evaluation
+#
+
+require "intar"
+require "appl"
+
+
+class Intar::Appl < Application
+
+  NAME      = "intar"
+  VERSION   = Intar::VERSION
+  SUMMARY   = "Interactive Ruby"
+  COPYRIGHT = "(C) 2008-2020 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
+
+  attr_writer :show, :prompt, :histmax
+  def histfile=   f ; @histfile   = nil_if_none f ; end
+  def configfile= f ; @configfile = nil_if_none f ; end
+  attr_bang :quiet, :bw, :catch_exit, :histall
+
+  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",             "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!,        "Don't quit on SystemExit exception"
+  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"
+
+  @params = {}
+  class <<self
+    attr_reader :params
+    def set **kwargs
+      @params.update **kwargs
+    end
+  end
+
+  def run
+    # @debug = true      # Only development.
+    read_cfg
+    Intar.open **params do |i|
+      i.execute @args.shift while @args.notempty?
+      i.run
+    end
+  end
+
+  private
+
+  def params
+    p = self.class.params
+    if @quiet then
+      p[ :show] = 0
+    elsif @show then
+      p[ :show] = Integer @show
+    end
+    p[ :prompt    ] = @prompt          if @prompt
+    p[ :color     ] = false            if @bw
+    p[ :catch_exit] = true             if @catch_exit
+    p[ :histhid   ] = false            if @histall
+    p[ :histfile  ] = @histfile        if @histfile
+    p[ :histmax   ] = Integer @histmax if @histmax
+    p
+  end
+
+  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
+    return unless @configfile
+    c = File.expand_path @configfile, "~"
+    return unless File.exists? c
+    load c
+  rescue Exception
+    $@.pop 2
+    e = $@.shift
+    puts "#{e}: #$! (#{$!.class})"
+    $@.each { |l| puts "\t#{l}" }
+    raise "Error in config file #{c}"
+  end
+
+  def nil_if_none var
+    case var
+      when "", "NONE" then nil
+      else                 var
+    end
+  end
+
+end
+
+Intar::Appl.run
+

data/lib/intar.rb

@@ -0,0 +1,564 @@
+#
+#  intar.rb  --  Interactive Ruby evaluation
+#
+
+require "supplement"
+require "supplement/terminal"
+require "intar/version"
+require "intar/prompt"
+require "intar/redirect"
+
+
+=begin rdoc
+
+This could be opened not only by the Intar executable but also
+everywhere inside your Ruby program.
+
+= Example 1
+
+  require "intar"
+  Intar.run
+
+
+= Example 2
+
+  require "intar"
+  a = "hello"
+  Intar.run a, prompt: "str(%(length)i):%03n%> "
+
+
+= Example 3
+
+  require "intar"
+  Intar.open show: 3, histfile: ".intar_history-example" do |i|
+    i.execute "puts inspect"
+    i.run
+  end
+
+
+=end
+
+
+class Object
+  def intar_binding
+    binding
+  end
+end
+
+
+class Intar
+
+  class <<self
+
+    def open obj = nil, **params
+      i = new obj, **params
+      yield i
+    end
+
+    def run obj = nil, **params
+      open obj, **params do |i| i.run end
+    end
+
+  end
+
+
+  DEFAULTS = {
+    prompt:     "%(32)c%i%c:%1c%03n%c%> ",
+    color:      true,
+    show:       1,
+    shownil:    false,
+    pager:      nil,
+    catch_exit: false,
+    histhid:    true,
+    histfile:   nil,
+    histmax:    500,
+  }
+
+  def initialize obj = nil, **params
+    @obj = obj.nil? ? (eval "self", TOPLEVEL_BINDING) : obj
+    @params = DEFAULTS.dup.update params
+    @binding = @obj.intar_binding
+    @n = 0
+    @prompt = Prompt.new
+  end
+
+
+  class Quit   < Exception ; end
+  class Failed < Exception ; end
+
+  def run
+    prompt_load_history
+    oldset = eval OLDSET, @binding
+    while l = readline do
+      begin
+        @redir = find_redirect l
+        r = if l =~ /\A\\(\w+|.)\s*(.*?)\s*\Z/ then
+          m = get_metacommand $1
+          send m.method, (eval_param $2)
+        else
+          begin
+            @redir.redirect_output do eval l, @binding, @file end
+          rescue SyntaxError
+            raise if l.end_with? $/
+            @previous = l
+            next
+          end
+        end
+      rescue Quit
+        break
+      rescue Failed
+        switchcolor 31, 1
+        puts $!
+        switchcolor
+        r = $!
+      rescue Exception
+        raise if SystemExit === $! and not @params[ :catch_exit]
+        show_exception
+        r = $!
+      else
+        display r
+      end
+      oldset.call r, @n
+    end
+    prompt_save_history
+  end
+
+  def execute code
+    eval code, @binding, "#{self.class}/execute"
+  end
+
+
+  private
+
+  def find_redirect line
+    RedirectPipe.detect line, @params[ :pager]  or
+    RedirectFile.detect line, @params[ :output] or
+    RedirectNone.new
+  end
+
+
+  OLDSET = <<~EOT
+    _, __, ___ = nil, nil, nil
+    proc { |r,n|
+      Array === __ or __ = []
+      Hash === ___ or ___ = {}
+      unless r.nil? or r.equal? __ or r.equal? ___ then
+        _ = r
+        __.unshift r
+        ___[ n] = r
+      end
+    }
+  EOT
+
+  autoload :Etc,    "etc"
+  autoload :Socket, "socket"
+
+  def cur_prompt prev
+    p = @params[ :prompt].to_s
+    p.gsub /%(?:
+               \(([^\)]+)?\)
+             |
+               ([+-]?[0-9]+(?:\.[0-9]+)?)
+             )?(.)/nx do
+      case $3
+        when "s" then @obj.to_s
+        when "i" then $1 ? (@obj.send $1) : @obj.inspect
+        when "n" then "%#$2d" % @n
+        when "t" then Time.now.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 color *($1 || $2 || "").split.map { |x| x.to_i }
+        when ">" then prev ? "." : Process.uid == 0 ? "#" : ">"
+        when "%" then $3
+        else          $&
+      end
+    end
+  end
+
+  def color *c
+    if @params[ :color] then
+      s = c.map { |i| "%d" % i }.join ";"
+      "\e[#{s}m"
+    end
+  end
+
+  def switchcolor *c
+    s = color *c
+    print 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
+    begin
+      cp = cur_prompt r
+      l = @prompt.ask cp
+      return if l.nil?
+      @prompt.push l unless !r and @params[ :histhid] and l =~ /\A[ \t]+/
+      if r then
+        r << $/ << l
+      else
+        r = l unless l.empty?
+      end
+      cp.strip!
+      cp.gsub! /\e\[[0-9]*(;[0-9]*)*m/, ""
+      @file = "#{self.class}/#{cp}"
+    end until r
+    switchcolor
+    r
+  end
+
+  # :stopdoc:
+  ARROW    = "=> "
+  ELLIPSIS = "..."
+  # :startdoc:
+
+  def display r
+    return if r.nil? and not @params[ :shownil]
+    s = @params[ :show]
+    s or return
+    s = s.to_i rescue 0
+    i = ARROW.dup
+    i << r.inspect
+    if s > 0 then
+      siz, = $stdout.wingeom
+      siz *= s
+      if i.length > siz then
+        i.cut! siz-ELLIPSIS.length
+        i << ELLIPSIS
+      end
+    end
+    puts i
+  end
+
+  def show_exception
+    unless $!.to_s.empty? then
+      switchcolor 31, 1
+      print $!
+      print " " unless $!.to_s =~ /\s\z/
+    end
+    switchcolor 31, 22
+    puts "(#{$!.class})"
+    switchcolor 33
+    $@.each { |b|
+      r = b.starts_with? __FILE__
+      break if r and (b.rest r) =~ /\A:\d+:/
+      puts b
+    }
+    switchcolor
+  end
+
+  def eval_param l
+    eot = "EOT0001"
+    eot.succ! while l[ eot]
+    l = eval "<<#{eot}\n#{l}\n#{eot}", @binding, @file
+    l.strip!
+    l.notempty?
+  end
+
+  def prompt_load_history
+    @prompt.load_history @params[ :histfile]
+  end
+  def prompt_save_history
+    @prompt.save_history @params[ :histfile], @params[ :histmax]
+  end
+  def prompt_scan_history
+    @prompt.scan_history do |l|
+      next if l =~ /\A\\/
+      yield l
+    end
+  end
+
+
+
+  Metacmds = Struct[ :method, :summary, :description]
+  @metacmds = {}
+  class <<self
+    attr_reader :metacmds
+    private
+    def method_added sym
+      if @mcd then
+        names, summary, desc = *@mcd
+        m = Metacmds[ sym, summary, desc]
+        names.each { |n|
+          @metacmds[ n] = m
+        }
+        @mcd = nil
+      end
+    end
+    def metacmd names, summary, desc
+      @mcd = [ names, summary, desc]
+    end
+  end
+
+  def get_metacommand name
+    self.class.metacmds[ name] or raise Failed, "Unknown Metacommand: #{name}"
+  end
+
+  metacmd %w(? h help), "Help for metacommands", <<~EOT
+    List of Metacommands or help on a specific command, if given.
+  EOT
+  def cmd_help x
+    @redir.redirect_output do
+      if x then
+        mc = get_metacommand x
+        names = cmds_list[ mc]
+        puts "Metacommand: #{names.join ' '}"
+        puts "Summary:     #{mc.summary}"
+        puts "Description:"
+        puts mc.description
+      else
+        l = cmds_list.map { |k,v| [v,k] }
+        puts "Metacommands:"
+        l.each { |names,mc|
+          puts "  %-20s  %s" % [ (names.join " "), mc.summary]
+        }
+      end
+    end
+    nil
+  end
+  def cmds_list
+    l = Hash.new { |h,k| h[k] = [] }
+    self.class.metacmds.each_pair { |k,v|
+      l[ v].push k
+    }
+    l
+  end
+
+  metacmd %w(v version), "Version information", <<~EOT
+    Print version number.
+  EOT
+  def cmd_version x
+    @redir.redirect_output do
+      puts "#{self.class} #{VERSION}"
+      VERSION
+    end
+  end
+
+  metacmd %w(q x quit exit), "Quit Intar", <<~EOT
+    Leave Intar.
+  EOT
+  def cmd_quit x
+    raise Quit
+  end
+
+  metacmd %w(cd), "Change directory", <<~EOT
+    Switch to a different working directory.
+    Former directories will be kept in a stack.
+
+      %[N]    exchange with stack item #N
+      =[N]    drop and set to stack item #N
+      -[N]    drop stack item #N
+
+    Default N is 1.
+  EOT
+  def cmd_cd x
+    @wds ||= []
+    y = Dir.getwd
+    if x =~ /\A([%=-])?(\d+)?\z/ then
+      x = $2 ? (@wds.delete_at -$2.to_i) : @wds.pop
+      x or raise Failed, ($2 ? "No directory ##$2." : "No last directory.")
+      case $1
+        when "-" then x = nil
+        when "=" then y = nil
+      end
+    end
+    if x then
+      x = File.expand_path x
+      Dir.chdir x rescue raise Failed, $!.to_s
+      @wds.push y if y
+      y = Dir.getwd
+      @wds.delete y
+    end
+    @redir.redirect_output do
+      i = @wds.length
+      @wds.each { |d|
+        puts "%2d  %s" % [ i, d]
+        i -= 1
+      }
+    end
+    y
+  end
+
+  metacmd %w($ env), "Set environment variable", <<~EOT
+    Set or display an environment variable.
+  EOT
+  def cmd_env x
+    if x then
+      cmds_split_assign x do |n,v|
+        if v then
+          v =~ /\A"((?:[^\\"]|\\.)*)"\z/ and v = ($1.gsub /\\(.)/, "\\1")
+          ENV[ n] = v
+        else
+          ENV[ n]
+        end
+      end
+    else
+      @redir.redirect_output do
+        ENV.keys.sort.each { |n|
+          puts "#{n}=#{ENV[ n]}"
+        }
+        nil
+      end
+    end
+  end
+  def cmds_split_assign x
+    n, v = x.split /\s*=\s*|\s+/, 2
+    yield n, v.notempty?
+  end
+
+  metacmd %w(! sh shell), "Run shell command", <<~EOT
+    Run a shell command or a subshell.
+  EOT
+  def cmd_shell x
+    @redir.redirect_output do
+      system x||ENV[ "SHELL"]||"/bin/sh" or
+        raise Failed, "Exit code: #{$?.exitstatus}"
+    end
+    nil
+  end
+
+  metacmd %w(p param), "Set parameter", <<~EOT
+    Set or display a parameter
+  EOT
+  def cmd_param x
+    if x then
+      cmds_split_assign x do |n,v|
+        if v then
+          @params[ n.to_sym] = parse_param v
+        else
+          @params[ n.to_sym]
+        end
+      end
+    else
+      @redir.redirect_output do
+        @params.keys.sort.each { |n|
+          puts "#{n}=#{@params[n].inspect}"
+        }
+        nil
+      end
+    end
+  end
+  def parse_param v
+    case v
+      when /\At(?:rue)?\z/i,  /\Ayes\z/i, /\Aon\z/i  then true
+      when /\Af(?:alse)?\z/i, /\Ano\z/i,  /\Aoff\z/i then false
+      when /\A(?:nil|none|-)\z/i                     then nil
+      when /\A(?:[+-])?\d+\z/i                       then $&.to_i
+      when /\A"((?:[^\\"]|\\.)*)"\z/                 then $1.gsub /\\(.)/, "\\1"
+      else                                                v
+    end
+  end
+
+  metacmd %w(< i input), "Load Ruby file", <<~EOT
+    Load a Ruby file and eval its contents.
+  EOT
+  def cmd_input x
+    x or raise Failed, "No input file given."
+    l = File.read x rescue raise Failed, $!.to_s
+    @redir.redirect_output do
+      eval l, @binding, x
+    end
+  end
+
+  metacmd %w(> o output), "Output to file", <<~EOT
+    Append output to a file.
+  EOT
+  def cmd_output x
+    if x then
+      File.open x, "w" do end rescue raise Failed, "File error: #$!"
+    end
+    @params[ :output] = x
+  end
+
+  metacmd %w(e edit), "Edit last command", <<~EOT
+    Take last command line from the history and open it in an editor.
+    Then execute the edited line.
+  EOT
+  def cmd_edit x
+    fn = tempname
+    x = Regexp.new x if x
+    p = prompt_scan_history { |l| break l if not x or l =~ x }
+    File.open fn, "w" do |f| f.write p end
+    begin
+      system ENV[ "EDITOR"]||ENV[ "VISUAL"]||"vi", fn or
+        raise Failed, "Executing editor failed: #{$?.exitstatus}"
+      p = File.read fn
+      p.strip!
+      @prompt.push p
+      @redir.redirect_output do eval p, @binding, @file end
+    ensure
+      File.unlink fn
+    end
+  end
+  def tempname
+    t = Time.now.strftime "%Y%m%d-%H%M%S"
+    File.expand_path "intar-#{t}-#$$.rb", ENV[ "TMPDR"]||"/tmp"
+  end
+
+  metacmd %w(^ hist history), "Manage history", <<~EOT
+    l load     Load history
+    s save     Save history
+    /          Search in history
+    [N [M]]    Show last N items (skip M)
+  EOT
+  def cmd_history x
+    case x
+      when "l", "load" then prompt_load_history
+      when "s", "save" then prompt_save_history
+      when %r(\A(\d+)?/\s*)              then search_history $1, $'
+      when %r(\A(\d+)(?:\s+(\d+))?\s*\z) then show_history $1.to_i, $2.to_i
+      when nil                           then show_history 5, 0
+      else                  raise Failed, "Unknown history command: #{x}"
+    end
+  end
+  def search_history num, pat
+    r = Regexp.new pat
+    num ||= 1
+    num = num.to_i.nonzero?
+    extract_from_history { |l|
+      if l =~ r then
+        if num then
+          break unless num > 0
+          num -= 1
+        end
+        next l
+      end
+    }
+  end
+  def show_history n, m
+    i, j = 0, 0
+    extract_from_history { |l|
+      i += 1
+      if i > m then
+        j += 1
+        break if j > n
+        next l
+      end
+    }
+  end
+  def extract_from_history
+    a = []
+    prompt_scan_history do |l|
+      n = yield l
+      a.push n if n
+    end
+  ensure
+    @redir.redirect_output do
+      while (p = a.pop) do
+        puts p
+      end
+    end
+  end
+
+end
+

data/lib/intar/prompt.rb

@@ -0,0 +1,128 @@
+#
+#  intar/prompt.rb  --  Prompt for Intar
+#
+
+require "supplement"
+require "readline"
+
+
+class Intar
+
+  class Prompt
+
+    def initialize histfile: nil, limit: nil
+      @limit = limit.nonzero?
+      Readline::HISTORY.clear
+      @new = 0
+    end
+
+    def ask prompt
+      l = Readline.readline prompt
+    rescue Interrupt
+      puts "^C  --  #{$!.inspect}"
+      retry
+    end
+
+    def last
+      Readline::HISTORY[-1] unless Readline::HISTORY.empty?
+    end
+
+    def scan_history
+      i = Readline::HISTORY.length
+      while i > 0 do
+        i -= 1
+        l = Readline::HISTORY[i]
+        yield l
+      end
+    end
+
+    def push item
+      item.empty? and return
+      last != item or return
+      Readline::HISTORY.push item
+      @new += 1
+    end
+
+    def load_history filepath
+      with_filepath filepath do |p|
+        read_file_if p do |f|
+          h = []
+          @new.times { h.push Readline::HISTORY.pop }
+          Readline::HISTORY.clear
+          f.each_line { |l|
+            l.chomp!
+            l.sub! "\r", "\n"
+            Readline::HISTORY.push l
+          }
+          Readline::HISTORY.push h.pop while h.any?
+        end
+        nil
+      end
+    end
+
+    def save_history filepath, maxsize
+      with_filepath filepath do |p|
+        lock_histfile p do
+          old, m = [], maxsize-@new
+          read_file_if p do |f|
+            f.each_line { |l|
+              old.size >= m and old.shift
+              old.push l
+            }
+          end
+          File.open p, "w" do |f|
+            old.each { |l| f.puts l }
+            i = Readline::HISTORY.length - @new
+            while i < Readline::HISTORY.length do
+              l = Readline::HISTORY[ i].sub "\n", "\r"
+              f.puts l
+              i += 1
+            end
+          end
+        end
+        nil
+      end
+    end
+
+    def limit_history max
+      n = Readline::HISTORY.length - max
+      n.times { Readline::HISTORY.shift }
+      @new > max and @new = max
+      nil
+    end
+
+    private
+
+    def with_filepath filepath
+      if filepath then
+        p = File.expand_path filepath, "~"
+        yield p
+      end
+    end
+
+    def read_file_if filepath
+      if File.exist? filepath then
+        File.open filepath do |f|
+          yield f
+        end
+      end
+    end
+
+    def lock_histfile filepath
+      l = "#{filepath}.lock"
+      loop do
+        File.open l, File::CREAT|File::EXCL do end
+        break
+      rescue Errno::EEXIST
+        puts "Lockfile #{l} exists."
+        sleep 1
+      end
+      yield
+    ensure
+      File.unlink l
+    end
+
+  end
+
+end
+

data/lib/intar/redirect.rb

@@ -0,0 +1,67 @@
+#
+#  intar/redirect.rb  --  Output redirection for Intar
+#
+
+require "supplement"
+
+
+class Intar
+
+  class RedirectNone
+    def redirect_output
+      yield
+    end
+  end
+
+  class Redirect
+    def redirect_output
+      out = outfile
+      stdin, stdout = $stdin.dup, $stdout.dup
+      $stdin .reopen "/dev/null"
+      $stdout.reopen out
+      yield
+    ensure
+      $stdin .reopen stdin
+      $stdout.reopen stdout
+      out.close
+    end
+  end
+
+  class RedirectPipe < Redirect
+    class <<self
+      def detect line, pager
+        if line.slice! /\s+\|\z/ then
+          new pager
+        end
+      end
+    end
+    def initialize pager
+      @pager = pager||ENV[ "PAGER"]||"more"
+    end
+    def outfile
+      IO.popen @pager.to_s, "w" rescue raise Failed, "Pipe error: #$!"
+    end
+  end
+
+  class RedirectFile < Redirect
+    class <<self
+      def detect line, outfile
+        if line.slice! /\s+>(>)?(\S+|"((?:[^\\"]|\\.)*)")\z/ then
+          p = $3 ? ($3.gsub /\\(.)/, "\\1") : $2
+          append = true if $1
+          new p, append
+        elsif outfile then
+          new outfile.to_s, true
+        end
+      end
+    end
+    def initialize path, append
+      @path, @append = path, append
+    end
+    def outfile
+      File.open @path, (@append ? "a" : "w") rescue raise Failed, "File error: #$!"
+    end
+  end
+
+end
+

data/lib/intar/version.rb

@@ -0,0 +1,10 @@
+#
+#  intar/version.rb  --  Version number
+#
+
+class Intar
+
+  VERSION = "2.0".freeze
+
+end
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: intar
+version: !ruby/object:Gem::Version
+  version: '2.0'
+platform: ruby
+authors:
+- Bertram Scharpf
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: appl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !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: 'This is a lean replacement for Irb.
+
+  '
+email: "<software@bertram-scharpf.de>"
+executables:
+- intar
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/intar
+- lib/intar.rb
+- lib/intar/prompt.rb
+- lib/intar/redirect.rb
+- lib/intar/version.rb
+homepage: http://www.bertram-scharpf.de
+licenses:
+- BSD-2-Clause
+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:
+- Ruby and some small Gems; Readline
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Interactive Ruby
+test_files: []