interact 0.3 → 0.4

data/lib/interact.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2011 Alex Suraci
 
 here = File.expand_path("../", __FILE__)
-require "#{here}/interact/interact"
 require "#{here}/interact/interactive"
+require "#{here}/interact/rewindable"

data/lib/interact/interactive.rb

@@ -1,82 +1,501 @@
-# Copyright (c) 2011 Alex Suraci
+# Copyright (c) 2012 Alex Suraci
 
 module Interactive
-  # Allow classes to enable/disable the rewind feature via +disable_rewind+
-  # and +enable_rewind+.
-  def self.included klass
-    class << klass
-      def disable_rewind
-        def self.rewind_enabled?
-          false
-        end
-      end
+  EVENTS = {
+    "\b" => :backspace,
+    "\t" => :tab,
+    "\x01" => :home,
+    "\x03" => :interrupt,
+    "\x04" => :eof,
+    "\x05" => :end,
+    "\x17" => :kill_word,
+    "\x7f" => :backspace,
+    "\r" => :enter,
+    "\n" => :enter
+  }
 
-      def enable_rewind
-        def self.rewind_enabled?
-          true
-        end
+  ESCAPES = {
+    "[A" => :up, "H" => :up,
+    "[B" => :down, "P" => :down,
+    "[C" => :right, "M" => :right,
+    "[D" => :left, "K" => :left,
+    "[3~" => :delete, "S" => :delete,
+    "[H" => :home, "G" => :home,
+    "[F" => :end, "O" => :end
+  }
+
+  # Wrap around the input options, the current answer, and the current
+  # position.
+  #
+  # Passed to handlers, which are expected to mutate +answer+ and +position+
+  # as they handle incoming events.
+  class InputState
+    attr_accessor :options, :answer, :position
+
+    def initialize(options = {}, answer = "", position = 0)
+      @options = options
+      @answer = answer
+      @position = position
+      @done = false
+    end
+
+    # Call to signal to the input reader that it can stop.
+    def done!
+      @done = true
+    end
+
+    # Is the input finished/complete?
+    def done?
+      @done
+    end
+
+    def censor(what)
+      if with = @options[:echo]
+        with * what.size
+      else
+        what
       end
+    end
+
+    def display(what)
+      print(censor(what))
+      @position += what.size
+    end
+
+    def back(x)
+      return if x == 0
+
+      print("\b" * (x * char_size))
+
+      @position -= x
+    end
+
+    def clear(x)
+      return if x == 0
 
-      def rewind_enabled?
-        true
+      print(" " * (x * char_size))
+
+      @position += x
+
+      back(x)
+    end
+
+    def goto(pos)
+      return if pos == position
+
+      if pos > position
+        display(answer[position .. pos])
+      else
+        print("\b" * (position - pos) * char_size)
       end
+
+      @position = pos
+    end
+
+    private
+
+    def char_size
+      @options[:echo] ? @options[:echo].size : 1
+    end
+  end
+
+  # Read a single character.
+  #
+  # [options] An optional hash containing the following options.
+  #
+  # input::
+  #   The input source (defaults to <code>$stdin</code>).
+  def read_char(options = {})
+    input = options[:input] || $stdin
+
+    with_char_io(input) do
+      get_character(input)
     end
+  end
 
-    klass.class_eval do
-      def rewind_enabled?
-        self.class.rewind_enabled?
+  # Read a single event.
+  #
+  # [options] An optional hash containing the following options.
+  #
+  # input::
+  #   The input source (defaults to <code>$stdin</code>).
+  def read_event(options = {})
+    input = options[:input] || $stdin
+
+    with_char_io(input) do
+      get_event(input)
+    end
+  end
+
+  # Read a line of input.
+  #
+  # [options] An optional hash containing the following options.
+  #
+  # input::
+  #   The input source (defaults to <code>$stdin</code>).
+  #
+  # echo::
+  #   A string to echo when showing the input; used for things like hiding
+  #   password input.
+  def read_line(options = {})
+    input = options[:input] || $stdin
+
+    state = input_state(options)
+    with_char_io(input) do
+      until state.done?
+        handler(get_event(input), state)
       end
     end
+
+    state.answer
   end
 
-  # Ask a question and get an answer. Rewind-aware; call +disable_rewind+ on
-  # your class to disable.
+  # Ask a question and get an answer.
   #
-  # See Interact#ask for the other possible values in +options+.
+  # See Interact#read_line for the other possible values in +options+.
   #
   # [question] The prompt, without ": " at the end.
   #
   # [options] An optional hash containing the following options.
   #
-  # forget::
-  #   Set to +true+ to prevent rewinding from remembering the user's answer.
-  def ask(question, options = {}, &callback)
-    rewind = Interact::HAS_CALLCC && rewind_enabled?
+  # default::
+  #   The default value, also used to attempt type conversion of the answer
+  #   (e.g. numeric/boolean).
+  #
+  # choices::
+  #   An array (or +Enumerable+) of strings to choose from.
+  #
+  # indexed::
+  #   Use alternative choice listing, and allow choosing by number. Good
+  #   for when there are many choices or choices with long names.
+  def ask(question, options = {})
+    choices = options[:choices] && options[:choices].to_a
+
+    list_choices(choices, options) if choices
+
+    while true
+      prompt(question, options)
+      ok, res = answered(read_line(options), options)
+      return res if ok
+    end
+  end
+
+  private
 
-    if rewind
-      prompt, answer = callcc { |cc| [cc, nil] }
+  def clear_input(state)
+    state.goto(0)
+    state.clear(state.answer.size)
+    state.answer = ""
+  end
+
+  def set_input(state, input)
+    clear_input(state)
+    state.display(input)
+    state.answer = input
+  end
+
+  def redraw_input(state)
+    pos = state.position
+    state.goto(0)
+    state.display(state.answer)
+    state.goto(pos)
+  end
+
+  def input_state(options)
+    InputState.new(options)
+  end
+
+  def get_event(input)
+    escaped = false
+    escape_seq = ""
+
+    while true
+      c = get_character(input)
+
+      if not c
+        return :eof
+      elsif c == "\e" || c == "\xE0"
+        escaped = true
+      elsif escaped
+        escape_seq << c
+
+        if cmd = ESCAPES[escape_seq]
+          return cmd
+        elsif ESCAPES.select { |k, v|
+                k.start_with? escape_seq
+              }.empty?
+          escaped, escape_seq = false, ""
+        end
+      elsif EVENTS.key? c
+        return EVENTS[c]
+      elsif c < " "
+        # ignore
+      else
+        return [:key, c]
+      end
+    end
+  end
+
+  def answered(ans, options)
+    print "\n"
+
+    if ans.empty?
+      if options.key?(:default)
+        [true, options[:default]]
+      end
+    elsif choices = options[:choices]
+      matches = choices.select { |x| x.start_with? ans }
+
+      if matches.size == 1
+        [true, matches.first]
+      elsif choices and ans =~ /^\s*\d+\s*$/ and \
+              res = choices.to_a[ans.to_i - 1]
+        [true, res]
+      elsif matches.size > 1
+        puts "Please disambiguate: #{matches.join " or "}?"
+        [false, nil]
+      else
+        puts "Unknown answer, please try again!"
+        [false, nil]
+      end
     else
-      prompt, answer = nil, nil
+      [true, match_type(ans, options[:default])]
     end
+  end
+
+  def list_choices(choices, options = {})
+    return unless options[:indexed]
+
+    choices.each_with_index do |o, i|
+      puts "#{i + 1}: #{o}"
+    end
+  end
+
+  def handler(which, state)
+    echo = state.options[:echo]
+
+    ans = state.answer
+    pos = state.position
+
+    case which
+    when :up
+      # nothing
+
+    when :down
+      # nothing
+
+    when :tab
+      if choices = state.options[:choices]
+        matches = choices.select { |c| c.start_with? ans }
+
+        if matches.size == 1
+          ans = state.answer = matches[0]
+          state.display(ans[pos .. -1])
+        else
+          print("\a") # bell
+        end
+      else
+        print("\a") # bell
+      end
+
+    when :right
+      unless pos == ans.size
+        state.display(ans[pos .. pos])
+      end
+
+    when :left
+      unless pos == 0
+        state.back(1)
+      end
+
+    when :delete
+      unless pos == ans.size
+        ans.slice!(pos, 1)
+        rest = ans[pos .. -1]
+        state.display(rest)
+        state.clear(1)
+        state.back(rest.size)
+      end
+
+    when :home
+      state.goto(0)
+
+    when :end
+      state.goto(ans.size)
+
+    when :backspace
+      if pos > 0
+        rest = ans[pos .. -1]
+
+        ans.slice!(pos - 1, 1)
+
+        state.back(1)
+        state.display(rest)
+        state.clear(1)
+        state.back(rest.size)
+      end
+
+    when :interrupt
+      raise Interrupt.new
+
+    when :eof
+      state.done! if ans.empty?
+
+    when :kill_word
+      if pos > 0
+        start = /[[:alnum:]]*\s*[^[:alnum:]]?$/ =~ ans[0 .. (pos - 1)]
+
+        if pos < ans.size
+          to_end = ans.size - pos
+          rest = ans[pos .. -1]
+          state.clear(to_end)
+        end
+
+        length = pos - start
+
+        ans.slice!(start, length)
+        state.back(length)
+        state.clear(length)
+
+        if to_end
+          state.display(rest)
+          state.back(to_end)
+        end
+      end
+
+    when :enter
+      state.done!
+
+    when Array
+      case which[0]
+      when :key
+        c = which[1]
+        rest = ans[pos .. -1]
+
+        ans.insert(pos, c)
+
+        state.display(c + rest)
+        state.back(rest.size)
+      end
 
-    if answer.nil?
-      default = options[:default]
     else
-      default = answer
+      return false
     end
 
-    prompts = (@__prompts ||= [])
+    true
+  end
+
+  def prompt(question, options = {})
+    print question
 
-    callback ||= options[:callback]
+    if (choices = options[:choices]) && !options[:indexed]
+      print " (#{choices.collect(&:to_s).join ", "})"
+    end
 
-    options[:prompts] = prompts
+    case options[:default]
+    when true
+      print " [Yn]"
+    when false
+      print " [yN]"
+    when nil
+    else
+      print " [#{options[:default]}]"
+    end
 
-    ans = Interact.ask(question, options, &callback)
+    print ": "
+  end
 
-    if rewind
-      prompts << [prompt, options[:forget] ? nil : ans]
+  def match_type(str, x)
+    case x
+    when Integer
+      str.to_i
+    when true, false
+      str.upcase.start_with? "Y"
+    else
+      str
     end
+  end
 
-    ans
+  def with_char_io(input)
+    before = set_input_state(input)
+    yield
+  ensure
+    restore_input_state(input, before)
   end
 
-  # Clear prompts.
-  #
-  # Questions asked after this are rewindable, but questions asked beforehand
-  # are no longer reachable.
-  #
-  # Use this after you've performed some mutation based on the user's input.
-  def finalize
-    @__prompts = []
+  def chr(x)
+    x && x.chr
+  end
+
+  private :chr
+
+  # Definitions for reading character-by-character with no echoing.
+  begin
+    require "Win32API"
+
+    def set_input_state(input)
+      nil
+    end
+
+    def restore_input_state(input, state)
+      nil
+    end
+
+    def get_character(input)
+      if input == STDIN
+        begin
+          chr(Win32API.new("msvcrt", "_getch", [], "L").call)
+        rescue
+          chr(Win32API.new("crtdll", "_getch", [], "L").call)
+        end
+      else
+        chr(input.getc)
+      end
+    end
+  rescue LoadError
+    begin
+      require "termios"
+
+      def set_input_state(input)
+        return nil unless input.tty?
+        before = Termio.getattr(input)
+
+        new = before.dup
+        new.c_lflag &= ~(Termios::ECHO | Termios::ICANON)
+        new.c_cc[Termios::VMIN] = 1
+
+        Termios.setattr(input, Termios::TCSANOW, new)
+
+        before
+      end
+
+      def restore_input_state(input, before)
+        if before
+          Termios.setattr(input, Termios::TCSANOW, before)
+        end
+      end
+
+      def get_character(input)
+        chr(input.getc)
+      end
+    rescue LoadError
+      def set_input_state(input)
+        return nil unless input.tty?
+
+        before = `stty -g`
+
+        system("stty -echo -icanon isig")
+
+        before
+      end
+
+      def restore_input_state(input, before)
+        system("stty #{before}") if before
+      end
+
+      def get_character(input)
+        chr(input.getc)
+      end
+    end
   end
 end

data/lib/interact/rewindable.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2012 Alex Suraci
+
+module Interactive::Rewindable
+  include Interactive
+
+  if defined? callcc
+    HAS_CALLCC = true #:nodoc:
+  else
+    begin
+      require "continuation"
+      HAS_CALLCC = true #:nodoc:
+    rescue LoadError
+      HAS_CALLCC = false #:nodoc:
+    end
+  end
+
+  class JumpToPrompt < Exception #:nodoc:
+    def initialize(prompt)
+      @prompt = prompt
+    end
+
+    def jump
+      print "\n"
+      @prompt[0].call(@prompt)
+    end
+  end
+
+  # Ask a question and get an answer. Rewind-aware; call +disable_rewind+ on
+  # your class to disable.
+  #
+  # See Interact#ask for the other possible values in +options+.
+  #
+  # [question] The prompt, without ": " at the end.
+  #
+  # [options] An optional hash containing the following options.
+  #
+  # forget::
+  #   Set to +true+ to prevent rewinding from remembering the user's answer.
+  def ask(question, options = {})
+    rewind = HAS_CALLCC
+
+    if rewind
+      prompt, answer = callcc { |cc| [cc, nil] }
+    else
+      prompt, answer = nil, nil
+    end
+
+    if answer
+      options[:default] = answer
+    end
+
+    prompts = (@__prompts ||= [])
+
+    options[:prompts] = prompts
+
+    ans = super
+
+    if rewind
+      prompts << [prompt, options[:forget] ? nil : ans]
+    end
+
+    ans
+  end
+
+  # Clear prompts.
+  #
+  # Questions asked after this are rewindable, but questions asked beforehand
+  # are no longer reachable.
+  #
+  # Use this after you've performed some mutation based on the user's input.
+  def finalize
+    @__prompts = []
+  end
+
+  def handler(which, state)
+    prompts = state.options[:prompts] || []
+
+    case which
+    when :up
+      if back = prompts.pop
+        raise JumpToPrompt, back
+      end
+    end
+
+    super
+  end
+
+  def with_char_io(input)
+    before = set_input_state(input)
+    yield
+  rescue JumpToPrompt => e
+    restore_input_state(input, before)
+    e.jump
+  ensure
+    restore_input_state(input, before)
+  end
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2011 Alex Suraci
 
 module Interact
-  VERSION = 0.3
+  VERSION = 0.4
 end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: interact
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 3
-  version: "0.3"
+  - 4
+  version: "0.4"
 platform: ruby
 authors: 
 - Alex Suraci
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-08 00:00:00 -08:00
+date: 2012-02-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,8 +59,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/interact/interact.rb
 - lib/interact/interactive.rb
+- lib/interact/rewindable.rb
 - lib/interact.rb
 - lib/version.rb
 has_rdoc: true

data/lib/interact/interact.rb

@@ -1,451 +0,0 @@
-# Copyright (c) 2011 Alex Suraci
-
-module Interact
-  WINDOWS = !!(RUBY_PLATFORM =~ /mingw|mswin32|cygwin/) #:nodoc:
-
-  if defined? callcc
-    HAS_CALLCC = true #:nodoc:
-  else
-    begin
-      require "continuation"
-      HAS_CALLCC = true #:nodoc:
-    rescue LoadError
-      HAS_CALLCC = false #:nodoc:
-    end
-  end
-
-  EVENTS = {
-    "\b" => :backspace,
-    "\t" => :tab,
-    "\x01" => :home,
-    "\x03" => :interrupt,
-    "\x04" => :eof,
-    "\x05" => :end,
-    "\x17" => :kill_word,
-    "\x7f" => :backspace,
-    "\r" => :enter,
-    "\n" => :enter
-  }
-
-  ESCAPES = {
-    "[A" => :up, "H" => :up,
-    "[B" => :down, "P" => :down,
-    "[C" => :right, "M" => :right,
-    "[D" => :left, "K" => :left,
-    "[3~" => :delete, "S" => :delete,
-    "[H" => :home, "G" => :home,
-    "[F" => :end, "O" => :end
-  }
-
-  class JumpToPrompt < Exception #:nodoc:
-    def initialize(prompt)
-      @prompt = prompt
-    end
-
-    def jump
-      print "\n"
-      @prompt[0].call(@prompt)
-    end
-  end
-
-  # Wrap around the input options, the current answer, and the current
-  # position.
-  #
-  # Passed to handlers, which are expected to mutate +answer+ and +position+
-  # as they handle incoming events.
-  class InputState
-    attr_accessor :options, :answer, :position
-
-    def initialize(options = {}, answer = "", position = 0)
-      @options = options
-      @answer = answer
-      @position = position
-      @done = false
-    end
-
-    # Call to signal to the input reader that it can stop.
-    def done!
-      @done = true
-    end
-
-    # Is the input finished/complete?
-    def done?
-      @done
-    end
-  end
-
-  class << self
-    # Read a single character.
-    #
-    # [options] An optional hash containing the following options.
-    #
-    # input::
-    #   The input source (defaults to <code>$stdin</code>).
-    def read_char(options = {})
-      input = options[:input] || $stdin
-
-      with_char_io(input) do
-        get_character(input)
-      end
-    end
-
-    # Read a single event.
-    #
-    # [options] An optional hash containing the following options.
-    #
-    # input::
-    #   The input source (defaults to <code>$stdin</code>).
-    #
-    # callback::
-    #   Called with the event.
-    def read_event(options = {}, &callback)
-      input = options[:input] || $stdin
-      callback ||= options[:callback]
-
-      with_char_io(input) do
-        e = get_event(input)
-
-        if callback
-          callback.call(e)
-        else
-          e
-        end
-      end
-    end
-
-    # Read a line of input.
-    #
-    # [options] An optional hash containing the following options.
-    #
-    # input::
-    #   The input source (defaults to <code>$stdin</code>).
-    #
-    # echo::
-    #   A string to echo when showing the input; used for things like hiding
-    #   password input.
-    #
-    # callback::
-    #   A block used to override certain actions.
-    #
-    #   The block should take two arguments:
-    #
-    #   - the event, e.g. <code>:up</code> or <code>[:key, X]</code> where
-    #     +X+ is a string containing a single character
-    #   - the +InputState+
-    #
-    #   The block should mutate the given state, and return +true+ if it
-    #   handled the event or +false+ if it didn't.
-    def read_line(options = {}, &callback)
-      input = options[:input] || $stdin
-      callback ||= options[:callback]
-
-      state = InputState.new(options)
-      with_char_io(input) do
-        until state.done?
-          handler(get_event(input), state, &callback)
-        end
-      end
-
-      state.answer
-    end
-
-    # Ask a question and get an answer.
-    #
-    # See Interact#read_line for the other possible values in +options+.
-    #
-    # [question] The prompt, without ": " at the end.
-    #
-    # [options] An optional hash containing the following options.
-    #
-    # default::
-    #   The default value, also used to attempt type conversion of the answer
-    #   (e.g. numeric/boolean).
-    #
-    # choices::
-    #   An array (or +Enumerable+) of strings to choose from.
-    #
-    # indexed::
-    #   Use alternative choice listing, and allow choosing by number. Good
-    #   for when there are many choices or choices with long names.
-    def ask(question, options = {}, &callback)
-      default = options[:default]
-      choices = options[:choices] && options[:choices].to_a
-      indexed = options[:indexed]
-      callback ||= options[:callback]
-
-      if indexed
-        choices.each_with_index do |o, i|
-          puts "#{i + 1}: #{o}"
-        end
-      end
-
-      while true
-        print prompt(question, default, !indexed && choices)
-
-        ans = read_line(options, &callback)
-
-        print "\n"
-
-        if ans.empty?
-          return default unless default.nil?
-        elsif choices
-          matches = choices.select { |x| x.start_with? ans }
-
-          if matches.size == 1
-            return matches.first
-          elsif indexed and ans =~ /^\s*\d+\s*$/ and \
-                  res = choices[ans.to_i - 1]
-            return res
-          elsif matches.size > 1
-            puts "Please disambiguate: #{matches.join " or "}?"
-          else
-            puts "Unknown answer, please try again!"
-          end
-        else
-          return match_type(ans, default)
-        end
-      end
-    end
-
-    private
-
-    def get_event(input)
-      escaped = false
-      escape_seq = ""
-
-      while c = get_character(input)
-        if c == "\e" || c == "\xE0"
-          escaped = true
-        elsif escaped
-          escape_seq << c
-
-          if cmd = Interact::ESCAPES[escape_seq]
-            return cmd
-          elsif Interact::ESCAPES.select { |k, v|
-                  k.start_with? escape_seq
-                }.empty?
-            escaped, escape_seq = false, ""
-          end
-        elsif Interact::EVENTS.key? c
-          return Interact::EVENTS[c]
-        elsif c < " "
-          # ignore
-        else
-          return [:key, c]
-        end
-      end
-    end
-
-    def handler(which, state)
-      if block_given?
-        res = yield which, state
-        return if res
-      end
-
-      echo = state.options[:echo]
-      prompts = state.options[:prompts] || []
-
-      ans = state.answer
-      pos = state.position
-
-      case which
-      when :up
-        if back = prompts.pop
-          raise Interact::JumpToPrompt, back
-        end
-
-      when :down
-        # nothing
-
-      when :tab
-        # nothing
-
-      when :right
-        unless pos == ans.size
-          print censor(ans[pos .. pos], echo)
-          state.position += 1
-        end
-
-      when :left
-        unless position == 0
-          print "\b"
-          state.position -= 1
-        end
-
-      when :delete
-        unless pos == ans.size
-          ans.slice!(pos, 1)
-          if Interact::WINDOWS
-            rest = ans[pos .. -1]
-            print(censor(rest, echo) + " \b" + ("\b" * rest.size))
-          else
-            print("\e[P")
-          end
-        end
-
-      when :home
-        print("\b" * pos)
-        state.position = 0
-
-      when :end
-        print(censor(ans[pos .. -1], echo))
-        state.position = ans.size
-
-      when :backspace
-        if pos > 0
-          ans.slice!(pos - 1, 1)
-
-          if Interact::WINDOWS
-            rest = ans[pos - 1 .. -1]
-            print("\b" + censor(rest, echo) + " \b" + ("\b" * rest.size))
-          else
-            print("\b\e[P")
-          end
-
-          state.position -= 1
-        end
-
-      when :interrupt
-        raise Interrupt.new
-
-      when :eof
-        state.done! if ans.empty?
-
-      when :kill_word
-        if pos > 0
-          start = /[^\s]*\s*$/ =~ ans[0 .. pos]
-          length = pos - start
-          ans.slice!(start, length)
-          print("\b" * length + " " * length + "\b" * length)
-          state.position = start
-        end
-
-      when :enter
-        state.done!
-
-      when Array
-        case which[0]
-        when :key
-          c = which[1]
-          rest = ans[pos .. -1]
-
-          ans.insert(pos, c)
-
-          print(censor(c + rest, echo) + ("\b" * rest.size))
-
-          state.position += 1
-        end
-
-      else
-        return false
-      end
-
-      true
-    end
-
-    def censor(str, with)
-      return str unless with
-      with * str.size
-    end
-
-    def prompt(question, default = nil, choices = nil)
-      msg = question.dup
-
-      if choices
-        msg << " (#{choices.collect(&:to_s).join ", "})"
-      end
-
-      case default
-      when true
-        msg << " [Yn]"
-      when false
-        msg << " [yN]"
-      else
-        msg << " [#{default}]" if default
-      end
-
-      "#{msg}: "
-    end
-
-    def match_type(str, x)
-      case x
-      when Integer
-        str.to_i
-      when true, false
-        str.upcase.start_with? "Y"
-      else
-        str
-      end
-    end
-
-    # Definitions for reading character-by-character with no echoing.
-    begin
-      require "Win32API"
-
-      def with_char_io(input)
-        yield
-      rescue Interact::JumpToPrompt => e
-        e.jump
-      end
-
-      def get_character(input)
-        if input == STDIN
-          begin
-            Win32API.new("msvcrt", "_getch", [], "L").call.chr
-          rescue
-            Win32API.new("crtdll", "_getch", [], "L").call.chr
-          end
-        else
-          input.getc.chr
-        end
-      end
-    rescue LoadError
-      begin
-        require "termios"
-
-        def with_char_io(input)
-          return yield unless input.tty?
-
-          before = Termios.getattr(input)
-
-          new = before.dup
-          new.c_lflag &= ~(Termios::ECHO | Termios::ICANON)
-          new.c_cc[Termios::VMIN] = 1
-
-          begin
-            Termios.setattr(input, Termios::TCSANOW, new)
-            yield
-          rescue Interact::JumpToPrompt => e
-            Termios.setattr(input, Termios::TCSANOW, before)
-            e.jump
-          ensure
-            Termios.setattr(input, Termios::TCSANOW, before)
-          end
-        end
-
-        def get_character(input)
-          input.getc.chr
-        end
-      rescue LoadError
-        def with_char_io(input)
-          return yield unless input.tty?
-
-          begin
-            before = `stty -g`
-            system("stty -echo -icanon isig")
-            yield
-          rescue Interact::JumpToPrompt => e
-            system("stty #{before}")
-            e.jump
-          ensure
-            system("stty #{before}")
-          end
-        end
-
-        def get_character(input)
-          input.getc.chr
-        end
-      end
-    end
-  end
-end