highline 1.7.10 → 2.0.0.pre.develop.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6de473a3d81859ef33fbaae779ea5d201215bfcb
-  data.tar.gz: 18d772cb47ed0d65627f782044a1f01e9c6baa9e
+  metadata.gz: 7f330e1d4093d9a373e0471827e2acdf89076eac
+  data.tar.gz: 1bba362856956f240a80312fe26e74966790b783
 SHA512:
-  metadata.gz: 10d9975025b395161bb73cae4f35e2047d4b935d1906ac91f306907100b6f13fdda740f6fc822de076e1fc08143cd64cd2f08fdcbe7ebece11d0b218945dba0a
-  data.tar.gz: 17600d300c546a50083e664ba0f76fda1b0e872b3e5409c3a53929dfdd13231a9eaa923270b83a3e98c8b2ce250c8d6cb1cca6c85b56169640f324debf62d755
+  metadata.gz: 36049605dccd8943c87037214ca65c02feab5ead5f1ca4579ba5491b0b8b966c9a49377c40f9fb99d53bd5a63ea86ef664c55cae40158cc53bef31b4413249cf
+  data.tar.gz: fdd91732e30725625a9197226d70d2a8bf99002c3a029094617bbed2048a3dadc93a3f95012eca5a87a0ca3f0f69ac5fb9007a3afc48cc6d253afaa81b4236d9

data/.gitignore

@@ -1,2 +1,4 @@
 doc
 pkg
+.DS_Store
+coverage

data/.simplecov

@@ -0,0 +1,5 @@
+unless SimpleCov.running
+  SimpleCov.start do
+    add_filter "test_"
+  end
+end

data/.travis.yml

@@ -3,15 +3,20 @@ language: ruby
 sudo: false
 script: "bundle exec rake test"
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.5
-  - 2.2.0
-  - 2.2.1
-  - 2.2.2
+  - 1.9
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
   - rbx-2
+  - jruby-19mode # JRuby in 1.9 mode
+  - jruby-head
+
 notifications:
   email: false
 matrix:
   allow_failures:
+    - rvm: ruby-head
     - rvm: rbx-2
+    - rvm: jruby-19mode # JRuby in 1.9 mode
+    - rvm: jruby-head

data/Changelog.md

@@ -2,26 +2,118 @@
 
 Below is a complete listing of changes for each revision of HighLine.
 
-### 1.7.10 / 2017-11-23
-* Add gemspec to Gemfile. Address #223. (@abinoam)
-
-### 1.7.9 / 2017-05-08
-* Fix frozen string issue on HighLine::Simulate. (Ivan Giuliani (@ivgiuliani), PR #210)
-
-### 1.7.8 / 2015-10-09
-* Fix some issues when paginating. (Nick Carboni (@carbonin) and Abinoam P. Marques Jr. (@abinoam), #168, PRs #169 #170)
-
-### 1.7.7 / 2015-09-22
-* Make HighLine::Question coerce its question argument into a String. (@97-109-107 and Abinoam P. Marques Jr. (@abinoam), #159, PR #160)
-
-### 1.7.6 / 2015-09-17
-* Fix a typo in a var name affecting solaris. (Danek Duvall (@dhduvall) and Abinoam P. Marques Jr. (@abinoam), #155, PR #156)
-
-### 1.7.5 / 2015-09-14
-* Support jruby9k for system extensions (Michael (@mmmries), PR #153)
-
-### 1.7.4 / 2015-06-16
-* Workaround on #55 for stty
+### 2.0.0-develop.2 / 2015-09-09
+
+(by Abinoam P. Marques Jr. - @abinoam)
+
+#### NOTES
+
+This version brings greater compatibility with JRuby and Windows.
+But we still have a lot of small issues in both platforms.
+We were able to unify/converge all approaches into using io/console,
+so we could delete old code that relied solely on stty, termios, java api and
+windows apis (DL and Fiddle).
+
+Another improvement is the beginning of what I called "acceptance tests".
+If you type ```rake acceptance``` you'll be guided through some tests
+where you have to input some thing and see if everything work as expected.
+This makes easier to catch bugs that otherwise would be over-sighted.
+
+#### CHANGES SUMMARY
+
+* Fix Simplecov - it was reporting erroneous code coverage
+* Add new tests. Improves code coverage
+* Extract HighLine::BuiltinStyles
+* Try to avoid nil checking
+* Try to avoid class variables (mis)use
+* Fix RDoc include path and some small fixes to the docs
+* Move HighLine::String to its own file
+* Add HighLine::Terminal::IOConsole
+  - Add an IOConsoleCompatibility module with some stubbed
+    methods for using at StringIO, File and Tempfile to help
+    on tests.
+  - Any enviroment that can require 'io/console' will
+    use HighLine::Terminal::IOConsole by default. This kind
+    of unifies most environments where HighLine runs. For
+    example, we can use Terminal::IOConsole on JRuby!!!
+* Add ruby-head and JRuby (19mode and head) to Travis CI matrix. Yes, this
+  our first step to a more peaceful JRuby compatibility.
+* Add AppVeyor Continuous Integration for Windows
+* Add _acceptance_ tests for HighLine
+  - Use ```rake acceptance``` to run them
+  - Basically it interactively asks the user to confirm if
+    some expected HighLine behavior is actually happening.
+    After that it gather some environment debug information,
+    so the use could send to the HighLine contributors in case
+    of failure.
+* Remove old and unused files (as a result of relying on io/console)
+  - JRuby
+  - Windows (DL and Fiddle)
+  - Termios
+* Fix some small (old and new) bugs
+* Make some more tuning for Windows compatibility
+* Make some more tuning for JRuby compatibility
+
+### 2.0.0-develop.1 / 2015-06-11
+
+This is the first development version of the 2.0.0 series. It's the begining of a refactoring phase on HighLine development cycle.
+
+#### SOME HISTORY
+
+In 2014 I emailed James Edward Gray II (@JEG2) about HighLine. One of his ideas was to completely refactor the library so that it could be easier to reuse and improve it. I've began my contributions to HighLine trying to fix some of the open issues at that time so that we could "freeze" a stable version of HighLine that people could rely on. Then I've began to study HighLine source code with James' help and started to refactor some parts of the code. Abinoam P. Marques Jr. (@abinoam)
+
+#### NOTES
+
+* This release differs from current master branch by more than 180 commits.
+* The main changes will be only summarized bellow (as there are many, and a detailed description of each is not productive).
+* You could try `git log -p` to see all of them.
+* During the last commits, all possible efforts were taken to preserve the tests passing status.
+* 100% test passing gives you no guarantee that this new version will work for you. This happens for many reasons. One of them is that we don't currently have 100% test coverage.
+* So, this version is not suitable for use in production.
+* [Metric_fu](https://github.com/metricfu/metric_fu) and [Code Climate](https://codeclimate.com/github/abinoam/highline) were used here not to strictly "guide" what should be changed, but to have some way to objectively measure the progresses made so far.
+
+#### CHANGES SUMMARY
+* Extracted a lot of smaller methods from bigger ones
+* Extracted smaller classes/modules from bigger ones, so they could be self contained with less external dependencies as possible, for example:
+  * HighLine::Statement
+  * HighLine::List
+  * HighLine::ListRenderer
+  * HighLine::TemplateRenderer
+  * HighLine::Question::AnswerConverter
+  * HighLine::Terminal
+  * HighLine::Terminal::UnixStty
+  * HighLine::Paginator
+  * HighLine::Wrapper
+* After extracting each class/module some refactoring were applied to them lowering code complexity
+
+#### METRICS SUMMARY
+Some of the metrics used to track progress are summarized bellow. Some of them have got a lot better as Flay, Flog and Reek, others like Cane haven't (probably because we didn't commented out the new code yet)
+
+__CODECLIMATE__
+
+* GPA: 3.60 -> 3.67 (higher is better)
+
+__CANE__ - reports code quality threshold violations (lower is better)
+
+* Total 92 -> 105
+  * Methods exceeding allowed Abc complexity: 14 -> 10
+  * Lines violating style requirements: 69 -> 72
+  * Class definitions requiring comments: 9 -> 23
+
+__FLAY__ - analyzes ruby code for structural similarities (code duplication - lower is better)
+
+* Total: 490 -> 94
+
+__FLOG__ - measures code complexity (lower is better)
+
+* Top 5% average: 127.9458 -> 40.99812
+* Average: 17.37982 -> 7.663875
+* Total: 2158.5 -> 1969.6
+
+__REEK__ - detects common code smells in ruby code (lower is better)
+
+* DuplicateMethodCall: 144 -> 54
+* TooManyStatements: 26 -> 30
 
 ### 1.7.3 / 2015-06-29
 * Add HighLine::Simulator tests (Bala Paranj (@bparanj) and Abinoam Marques Jr. (@abinoam), #142, PR #143)

data/Gemfile

@@ -1,11 +1,12 @@
 source "https://rubygems.org"
 
-gemspec
+gem "rake", require: false
+gem "rdoc", require: false
 
-gem "rake", :require => false
-gem "rdoc", :require => false
-
-group(:development, :tests) do
-  gem "code_statistics", :require => false
-  gem "test-unit", :require => false
+group :development, :test do
+  gem "code_statistics", require: false
+  gem "minitest", require: false
 end
+
+gem "codeclimate-test-reporter", group: :test, require: false
+gem "simplecov", group: :test, require: false

data/README.rdoc

@@ -3,7 +3,10 @@
 by James Edward Gray II
 
 {<img src="https://travis-ci.org/JEG2/highline.svg" alt="Build Status" />}[https://travis-ci.org/JEG2/highline]
+{<img src="https://ci.appveyor.com/api/projects/status/4p05fijpah77d28x?svg=true" alt="AppVeyor Build Status" />}[https://ci.appveyor.com/project/abinoam/highline]
 {<img src="https://img.shields.io/gem/v/highline.svg?style=flat" />}[http://rubygems.org/gems/highline]
+{<img src="https://codeclimate.com/github/JEG2/highline/badges/gpa.svg" />}[https://codeclimate.com/github/JEG2/highline]
+{<img src="https://codeclimate.com/github/JEG2/highline/badges/coverage.svg" />}[https://codeclimate.com/github/JEG2/highline/coverage]
 
 == Description
 

data/Rakefile

@@ -10,16 +10,16 @@ task :default => [:test]
 
 Rake::TestTask.new do |test|
   test.libs       = ["lib", "test"]
-  test.test_files = FileList[ "test/tc_*.rb"]
   test.verbose    = true
   test.warning    = true
+  test.test_files = FileList['test/test*.rb']
 end
 
 RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include( "README.rdoc", "INSTALL",
                            "TODO", "Changelog.md",
                            "AUTHORS", "COPYING",
-                           "LICENSE", "lib /*.rb" )
+                           "LICENSE", "lib/**/*.rb")
   rdoc.main     = "README.rdoc"
   rdoc.rdoc_dir = "doc/html"
   rdoc.title    = "HighLine Documentation"
@@ -28,3 +28,8 @@ end
 Gem::PackageTask.new(SPEC) do |package|
   # do nothing:  I just need a gem but this block is required
 end
+
+desc "Run some interactive acceptance tests"
+task :acceptance do
+  load "test/acceptance/acceptance.rb"
+end

data/appveyor.yml

@@ -0,0 +1,19 @@
+version: '{build}'
+
+skip_tags: true
+
+environment:
+  matrix:
+    - ruby_version: "21"
+    - ruby_version: "21-x64"
+
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - gem install bundler --no-document -v 1.10.5
+  - bundle install --retry=3
+
+test_script:
+  - bundle exec rake
+
+build: off
+

data/examples/asking_for_arrays.rb

@@ -9,6 +9,9 @@ require "rubygems"
 require "highline/import"
 require "pp"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 grades = ask( "Enter test scores (or a blank line to quit):",
               lambda { |ans| ans =~ /^-?\d+$/ ? Integer(ans) : ans} ) do |q|
   q.gather = ""

data/examples/basic_usage.rb

@@ -9,6 +9,9 @@ require "rubygems"
 require "highline/import"
 require "yaml"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 contacts = [ ]
 
 class NameClass

data/examples/get_character.rb

@@ -3,6 +3,9 @@
 require "rubygems"
 require "highline/import"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 choices = "ynaq"
 answer = ask("Your choice [#{choices}]? ") do |q|
            q.echo      = false

data/examples/limit.rb

@@ -8,5 +8,8 @@
 require "rubygems"
 require "highline/import"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 text = ask("Enter text (max 10 chars): ") { |q| q.limit = 10 }
 puts "You entered: #{text}!"

data/examples/menus.rb

@@ -3,6 +3,9 @@
 require "rubygems"
 require "highline/import"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 # The old way, using ask() and say()...
 choices = %w{ruby python perl}
 say("This is the old way using ask() and say()...")

data/examples/overwrite.rb

@@ -8,6 +8,9 @@
 require 'rubygems'
 require 'highline/import'
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 prompt = "here is your password:"
 ask(
   "#{prompt} <%= color('mypassword', RED, BOLD) %> (Press Any Key to blank) "

data/examples/password.rb

@@ -3,5 +3,8 @@
 require "rubygems"
 require "highline/import"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 pass = ask("Enter your password:  ") { |q| q.echo = false }
 puts "Your password is #{pass}!"

data/examples/repeat_entry.rb

@@ -3,6 +3,9 @@
 require "rubygems"
 require "highline/import"
 
+puts "Using: #{$terminal.terminal.class}"
+puts
+
 tounge_twister = ask("... try saying that three times fast") do |q|
   q.gather = 3
   q.verify_match = true
@@ -11,7 +14,7 @@ end
 
 puts "Ok, you did it."
 
-pass = ask("<%= @key %>:  ") do |q|
+pass = ask("<%= key %>:  ") do |q|
   q.echo = '*'
   q.verify_match = true
   q.gather = {"Enter a password" => '',

data/lib/highline.rb

@@ -1,4 +1,6 @@
 # coding: utf-8
+
+#--
 # highline.rb
 #
 #  Created by James Edward Gray II on 2005-04-26.
@@ -12,12 +14,17 @@ require "erb"
 require "optparse"
 require "stringio"
 require "abbrev"
-require "highline/system_extensions"
+require "highline/terminal"
+require "highline/custom_errors"
 require "highline/question"
+require "highline/question_asker"
 require "highline/menu"
 require "highline/color_scheme"
 require "highline/style"
 require "highline/version"
+require "highline/statement"
+require "highline/list_renderer"
+require "highline/builtin_styles"
 
 #
 # A HighLine object is a "high-level line oriented" shell over an input and an
@@ -29,22 +36,20 @@ require "highline/version"
 # checking, convert types, etc.
 #
 class HighLine
-  # An internal HighLine error.  User code does not need to trap this.
-  class QuestionError < StandardError
-    # do nothing, just creating a unique error type
-  end
+  include BuiltinStyles
+  include CustomErrors
 
   # The setting used to disable color output.
-  @@use_color = true
+  @use_color = true
 
   # Pass +false+ to _setting_ to turn off HighLine's color escapes.
   def self.use_color=( setting )
-    @@use_color = setting
+    @use_color = setting
   end
 
   # Returns true if HighLine is currently using color escapes.
   def self.use_color?
-    @@use_color
+    @use_color
   end
 
   # For checking if the current version of HighLine supports RGB colors
@@ -55,122 +60,49 @@ class HighLine
   end
 
   # The setting used to disable EOF tracking.
-  @@track_eof = true
+  @track_eof = true
 
   # Pass +false+ to _setting_ to turn off HighLine's EOF tracking.
   def self.track_eof=( setting )
-    @@track_eof = setting
+    @track_eof = setting
   end
 
   # Returns true if HighLine is currently tracking EOF for input.
   def self.track_eof?
-    @@track_eof
+    @track_eof
+  end
+
+  def track_eof?
+    self.class.track_eof?
   end
 
   # The setting used to control color schemes.
-  @@color_scheme = nil
+  @color_scheme = nil
 
   # Pass ColorScheme to _setting_ to set a HighLine color scheme.
   def self.color_scheme=( setting )
-    @@color_scheme = setting
+    @color_scheme = setting
   end
 
   # Returns the current color scheme.
   def self.color_scheme
-    @@color_scheme
+    @color_scheme
   end
 
   # Returns +true+ if HighLine is currently using a color scheme.
   def self.using_color_scheme?
-    not @@color_scheme.nil?
+    !!@color_scheme
   end
 
-  #
-  # Embed in a String to clear all previous ANSI sequences.  This *MUST* be
-  # done before the program exits!
-  #
-
-  ERASE_LINE_STYLE = Style.new(:name=>:erase_line, :builtin=>true, :code=>"\e[K")  # Erase the current line of terminal output
-  ERASE_CHAR_STYLE = Style.new(:name=>:erase_char, :builtin=>true, :code=>"\e[P")  # Erase the character under the cursor.
-  CLEAR_STYLE      = Style.new(:name=>:clear,      :builtin=>true, :code=>"\e[0m") # Clear color settings
-  RESET_STYLE      = Style.new(:name=>:reset,      :builtin=>true, :code=>"\e[0m") # Alias for CLEAR.
-  BOLD_STYLE       = Style.new(:name=>:bold,       :builtin=>true, :code=>"\e[1m") # Bold; Note: bold + a color works as you'd expect,
-                                                              # for example bold black. Bold without a color displays
-                                                              # the system-defined bold color (e.g. red on Mac iTerm)
-  DARK_STYLE       = Style.new(:name=>:dark,       :builtin=>true, :code=>"\e[2m") # Dark; support uncommon
-  UNDERLINE_STYLE  = Style.new(:name=>:underline,  :builtin=>true, :code=>"\e[4m") # Underline
-  UNDERSCORE_STYLE = Style.new(:name=>:underscore, :builtin=>true, :code=>"\e[4m") # Alias for UNDERLINE
-  BLINK_STYLE      = Style.new(:name=>:blink,      :builtin=>true, :code=>"\e[5m") # Blink; support uncommon
-  REVERSE_STYLE    = Style.new(:name=>:reverse,    :builtin=>true, :code=>"\e[7m") # Reverse foreground and background
-  CONCEALED_STYLE  = Style.new(:name=>:concealed,  :builtin=>true, :code=>"\e[8m") # Concealed; support uncommon
-
-  STYLES = %w{CLEAR RESET BOLD DARK UNDERLINE UNDERSCORE BLINK REVERSE CONCEALED}
-
-  # These RGB colors are approximate; see http://en.wikipedia.org/wiki/ANSI_escape_code
-  BLACK_STYLE      = Style.new(:name=>:black,      :builtin=>true, :code=>"\e[30m", :rgb=>[  0,  0,  0])
-  RED_STYLE        = Style.new(:name=>:red,        :builtin=>true, :code=>"\e[31m", :rgb=>[128,  0,  0])
-  GREEN_STYLE      = Style.new(:name=>:green,      :builtin=>true, :code=>"\e[32m", :rgb=>[  0,128,  0])
-  BLUE_STYLE       = Style.new(:name=>:blue,       :builtin=>true, :code=>"\e[34m", :rgb=>[  0,  0,128])
-  YELLOW_STYLE     = Style.new(:name=>:yellow,     :builtin=>true, :code=>"\e[33m", :rgb=>[128,128,  0])
-  MAGENTA_STYLE    = Style.new(:name=>:magenta,    :builtin=>true, :code=>"\e[35m", :rgb=>[128,  0,128])
-  CYAN_STYLE       = Style.new(:name=>:cyan,       :builtin=>true, :code=>"\e[36m", :rgb=>[  0,128,128])
-  # On Mac OSX Terminal, white is actually gray
-  WHITE_STYLE      = Style.new(:name=>:white,      :builtin=>true, :code=>"\e[37m", :rgb=>[192,192,192])
-  # Alias for WHITE, since WHITE is actually a light gray on Macs
-  GRAY_STYLE       = Style.new(:name=>:gray,       :builtin=>true, :code=>"\e[37m", :rgb=>[192,192,192])
-  GREY_STYLE       = Style.new(:name=>:grey,       :builtin=>true, :code=>"\e[37m", :rgb=>[192,192,192])
-  # On Mac OSX Terminal, this is black foreground, or bright white background.
-  # Also used as base for RGB colors, if available
-  NONE_STYLE       = Style.new(:name=>:none,       :builtin=>true, :code=>"\e[38m", :rgb=>[  0,  0,  0])
-
-  BASIC_COLORS = %w{BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE GRAY GREY NONE}
-
-  colors = BASIC_COLORS.dup
-  BASIC_COLORS.each do |color|
-    bright_color = "BRIGHT_#{color}"
-    colors << bright_color
-    const_set bright_color+'_STYLE', const_get(color + '_STYLE').bright
-
-    light_color = "LIGHT_#{color}"
-    colors << light_color
-    const_set light_color+'_STYLE', const_get(color + '_STYLE').light
-  end
-  COLORS = colors
-
-  colors.each do |color|
-    const_set color, const_get("#{color}_STYLE").code
-    const_set "ON_#{color}_STYLE", const_get("#{color}_STYLE").on
-    const_set "ON_#{color}", const_get("ON_#{color}_STYLE").code
+  # Reset HighLine to default.
+  # Clears Style index and reset color scheme.
+  def self.reset
+    Style.clear_index
+    reset_color_scheme
   end
-  ON_NONE_STYLE.rgb = [255,255,255] # Override; white background
 
-  STYLES.each do |style|
-    const_set style, const_get("#{style}_STYLE").code
-  end
-
-  # For RGB colors:
-  def self.const_missing(name)
-    if name.to_s =~ /^(ON_)?(RGB_)([A-F0-9]{6})(_STYLE)?$/ # RGB color
-      on = $1
-      suffix = $4
-      if suffix
-        code_name = $1.to_s + $2 + $3
-      else
-        code_name = name.to_s
-      end
-      style_name = code_name + '_STYLE'
-      style = Style.rgb($3)
-      style = style.on if on
-      const_set(style_name, style)
-      const_set(code_name, style.code)
-      if suffix
-        style
-      else
-        style.code
-      end
-    else
-      raise NameError, "Bad color or uninitialized constant #{name}"
-    end
+  def self.reset_color_scheme
+    self.color_scheme = nil
   end
 
   #
@@ -183,26 +115,19 @@ class HighLine
     @output  = output
 
     @multi_indent = true
-    @indent_size = indent_size
+    @indent_size  = indent_size
     @indent_level = indent_level
 
     self.wrap_at = wrap_at
     self.page_at = page_at
 
-    @question = nil
-    @answer   = nil
-    @menu     = nil
     @header   = nil
     @prompt   = nil
-    @gather   = nil
-    @answers  = nil
     @key      = nil
 
-    initialize_system_extensions if respond_to?(:initialize_system_extensions)
+    @terminal = HighLine::Terminal.get_terminal(input, output)
   end
 
-  include HighLine::SystemExtensions
-
   # The current column setting for wrapping output.
   attr_reader :wrap_at
   # The current row setting for paging output.
@@ -214,6 +139,15 @@ class HighLine
   # The indentation level
   attr_accessor :indent_level
 
+  attr_reader :input, :output
+
+  attr_accessor :key
+
+  # System specific that responds to #initialize_system_extensions,
+  # #terminal_size, #raw_no_echo_mode, #restore_mode, #get_character.
+  # It polymorphically handles specific cases for different platforms.
+  attr_reader :terminal
+
   #
   # A shortcut to HighLine.ask() a question that only accepts "yes" or "no"
   # answers ("y" and "n" are allowed) and returns +true+ or +false+
@@ -242,75 +176,15 @@ class HighLine
   # HighLine::Question for more information about _answer_type_ and what's
   # valid in the code block.
   #
-  # If <tt>@question</tt> is set before ask() is called, parameters are
-  # ignored and that object (must be a HighLine::Question) is used to drive
-  # the process instead.
-  #
   # Raises EOFError if input is exhausted.
   #
-  def ask( question, answer_type = nil, &details ) # :yields: question
-    @question ||= Question.new(question, answer_type, &details)
-
-    return gather if @question.gather
-
-    # readline() needs to handle its own output, but readline only supports
-    # full line reading.  Therefore if @question.echo is anything but true,
-    # the prompt will not be issued. And we have to account for that now.
-    # Also, JRuby-1.7's ConsoleReader.readLine() needs to be passed the prompt
-    # to handle line editing properly.
-    say(@question) unless ((JRUBY or @question.readline) and (@question.echo == true and @question.limit.nil?))
-
-    begin
-      @answer = @question.answer_or_default(get_response)
-      unless @question.valid_answer?(@answer)
-        explain_error(:not_valid)
-        raise QuestionError
-      end
+  def ask(template_or_question, answer_type = nil, &details)
+    question = Question.build(template_or_question, answer_type, &details)
 
-      @answer = @question.convert(@answer)
-
-      if @question.in_range?(@answer)
-        if @question.confirm
-          # need to add a layer of scope to ask a question inside a
-          # question, without destroying instance data
-          context_change = self.class.new(@input, @output, @wrap_at, @page_at, @indent_size, @indent_level)
-          if @question.confirm == true
-            confirm_question = "Are you sure?  "
-          else
-            # evaluate ERb under initial scope, so it will have
-            # access to @question and @answer
-            template  = ERB.new(@question.confirm, nil, "%")
-            confirm_question = template.result(binding)
-          end
-          unless context_change.agree(confirm_question)
-            explain_error(nil)
-            raise QuestionError
-          end
-        end
-
-        @answer
-      else
-        explain_error(:not_in_range)
-        raise QuestionError
-      end
-    rescue QuestionError
-      retry
-    rescue ArgumentError, NameError => error
-      raise if error.is_a?(NoMethodError)
-      if error.message =~ /ambiguous/
-        # the assumption here is that OptionParser::Completion#complete
-        # (used for ambiguity resolution) throws exceptions containing
-        # the word 'ambiguous' whenever resolution fails
-        explain_error(:ambiguous_completion)
-      else
-        explain_error(:invalid_type)
-      end
-      retry
-    rescue Question::NoAutoCompleteMatch
-      explain_error(:no_completion)
-      retry
-    ensure
-      @question = nil    # Reset Question object.
+    if question.gather
+      QuestionAsker.new(question, self).gather_answers
+    else
+      QuestionAsker.new(question, self).ask_once
     end
   end
 
@@ -330,40 +204,34 @@ class HighLine
   # Raises EOFError if input is exhausted.
   #
   def choose( *items, &details )
-    @menu = @question = Menu.new(&details)
-    @menu.choices(*items) unless items.empty?
+    menu = Menu.new(&details)
+    menu.choices(*items) unless items.empty?
 
     # Set auto-completion
-    @menu.completion = @menu.options
-    # Set _answer_type_ so we can double as the Question for ask().
-    @menu.answer_type = if @menu.shell
-      lambda do |command|    # shell-style selection
-        first_word = command.to_s.split.first || ""
+    menu.completion = menu.options
 
-        options = @menu.options
-        options.extend(OptionParser::Completion)
-        answer = options.complete(first_word)
+    shell_style_lambda = lambda do |command|    # shell-style selection
+      first_word = command.to_s.split.first || ""
 
-        if answer.nil?
-          raise Question::NoAutoCompleteMatch
-        end
+      options = menu.options
+      options.extend(OptionParser::Completion)
+      answer = options.complete(first_word)
 
-        [answer.last, command.sub(/^\s*#{first_word}\s*/, "")]
-      end
-    else
-      @menu.options          # normal menu selection, by index or name
+      raise Question::NoAutoCompleteMatch unless answer
+
+      [answer.last, command.sub(/^\s*#{first_word}\s*/, "")]
     end
 
-    # Provide hooks for ERb layouts.
-    @header   = @menu.header
-    @prompt   = @menu.prompt
+    # Set _answer_type_ so we can double as the Question for ask().
+    # menu.option = normal menu selection, by index or name
+    menu.answer_type = menu.shell ? shell_style_lambda : menu.options
+
+    selected = ask(menu)
 
-    if @menu.shell
-      selected = ask("Ignored", @menu.answer_type)
-      @menu.select(self, *selected)
+    if menu.shell
+      menu.select(self, *selected)
     else
-      selected = ask("Ignored", @menu.answer_type)
-      @menu.select(self, selected)
+      menu.select(self, selected)
     end
   end
 
@@ -408,203 +276,8 @@ class HighLine
     self.class.uncolor(string)
   end
 
-  #
-  # This method is a utility for quickly and easily laying out lists.  It can
-  # be accessed within ERb replacements of any text that will be sent to the
-  # user.
-  #
-  # The only required parameter is _items_, which should be the Array of items
-  # to list.  A specified _mode_ controls how that list is formed and _option_
-  # has different effects, depending on the _mode_.  Recognized modes are:
-  #
-  # <tt>:columns_across</tt>::         _items_ will be placed in columns,
-  #                                    flowing from left to right.  If given,
-  #                                    _option_ is the number of columns to be
-  #                                    used.  When absent, columns will be
-  #                                    determined based on _wrap_at_ or a
-  #                                    default of 80 characters.
-  # <tt>:columns_down</tt>::           Identical to <tt>:columns_across</tt>,
-  #                                    save flow goes down.
-  # <tt>:uneven_columns_across</tt>::  Like <tt>:columns_across</tt> but each
-  #                                    column is sized independently.
-  # <tt>:uneven_columns_down</tt>::    Like <tt>:columns_down</tt> but each
-  #                                    column is sized independently.
-  # <tt>:inline</tt>::                 All _items_ are placed on a single line.
-  #                                    The last two _items_ are separated by
-  #                                    _option_ or a default of " or ".  All
-  #                                    other _items_ are separated by ", ".
-  # <tt>:rows</tt>::                   The default mode.  Each of the _items_ is
-  #                                    placed on its own line.  The _option_
-  #                                    parameter is ignored in this mode.
-  #
-  # Each member of the _items_ Array is passed through ERb and thus can contain
-  # their own expansions.  Color escape expansions do not contribute to the
-  # final field width.
-  #
-  def list( items, mode = :rows, option = nil )
-    items = items.to_ary.map do |item|
-      if item.nil?
-        ""
-      else
-        ERB.new(item, nil, "%").result(binding)
-      end
-    end
-
-    if items.empty?
-      ""
-    else
-      case mode
-      when :inline
-        option = " or " if option.nil?
-
-        if items.size == 1
-          items.first
-        else
-          items[0..-2].join(", ") + "#{option}#{items.last}"
-        end
-      when :columns_across, :columns_down
-        max_length = actual_length(
-          items.max { |a, b| actual_length(a) <=> actual_length(b) }
-        )
-
-        if option.nil?
-          limit  = @wrap_at || 80
-          option = (limit + 2) / (max_length + 2)
-        end
-
-        items = items.map do |item|
-          pad = max_length + (item.to_s.length - actual_length(item))
-          "%-#{pad}s" % item
-        end
-        row_count = (items.size / option.to_f).ceil
-
-        if mode == :columns_across
-          rows = Array.new(row_count) { Array.new }
-          items.each_with_index do |item, index|
-            rows[index / option] << item
-          end
-
-          rows.map { |row| row.join("  ") + "\n" }.join
-        else
-          columns = Array.new(option) { Array.new }
-          items.each_with_index do |item, index|
-            columns[index / row_count] << item
-          end
-
-          list = ""
-          columns.first.size.times do |index|
-            list << columns.map { |column| column[index] }.
-                            compact.join("  ") + "\n"
-          end
-          list
-        end
-      when :uneven_columns_across
-        if option.nil?
-          limit = @wrap_at || 80
-          items.size.downto(1) do |column_count|
-            row_count = (items.size / column_count.to_f).ceil
-            rows      = Array.new(row_count) { Array.new }
-            items.each_with_index do |item, index|
-              rows[index / column_count] << item
-            end
-
-            widths = Array.new(column_count, 0)
-            rows.each do |row|
-              row.each_with_index do |field, column|
-                size           = actual_length(field)
-                widths[column] = size if size > widths[column]
-              end
-            end
-
-            if column_count == 1 or
-               widths.inject(0) { |sum, n| sum + n + 2 } <= limit + 2
-              return rows.map { |row|
-                row.zip(widths).map { |field, i|
-                  "%-#{i + (field.to_s.length - actual_length(field))}s" % field
-                }.join("  ") + "\n"
-              }.join
-            end
-          end
-        else
-          row_count = (items.size / option.to_f).ceil
-          rows      = Array.new(row_count) { Array.new }
-          items.each_with_index do |item, index|
-            rows[index / option] << item
-          end
-
-          widths = Array.new(option, 0)
-          rows.each do |row|
-            row.each_with_index do |field, column|
-              size           = actual_length(field)
-              widths[column] = size if size > widths[column]
-            end
-          end
-
-          return rows.map { |row|
-            row.zip(widths).map { |field, i|
-              "%-#{i + (field.to_s.length - actual_length(field))}s" % field
-            }.join("  ") + "\n"
-          }.join
-        end
-      when :uneven_columns_down
-        if option.nil?
-          limit = @wrap_at || 80
-          items.size.downto(1) do |column_count|
-            row_count = (items.size / column_count.to_f).ceil
-            columns   = Array.new(column_count) { Array.new }
-            items.each_with_index do |item, index|
-              columns[index / row_count] << item
-            end
-
-            widths = Array.new(column_count, 0)
-            columns.each_with_index do |column, i|
-              column.each do |field|
-                size      = actual_length(field)
-                widths[i] = size if size > widths[i]
-              end
-            end
-
-            if column_count == 1 or
-               widths.inject(0) { |sum, n| sum + n + 2 } <= limit + 2
-              list = ""
-              columns.first.size.times do |index|
-                list << columns.zip(widths).map { |column, width|
-                  field = column[index]
-                  "%-#{width + (field.to_s.length - actual_length(field))}s" %
-                  field
-                }.compact.join("  ").strip + "\n"
-              end
-              return list
-            end
-          end
-        else
-          row_count = (items.size / option.to_f).ceil
-          columns   = Array.new(option) { Array.new }
-          items.each_with_index do |item, index|
-            columns[index / row_count] << item
-          end
-
-          widths = Array.new(option, 0)
-          columns.each_with_index do |column, i|
-            column.each do |field|
-              size      = actual_length(field)
-              widths[i] = size if size > widths[i]
-            end
-          end
-
-          list = ""
-          columns.first.size.times do |index|
-            list << columns.zip(widths).map { |column, width|
-              field = column[index]
-              "%-#{width + (field.to_s.length - actual_length(field))}s" % field
-            }.compact.join("  ").strip + "\n"
-          end
-          return list
-        end
-      else
-        items.map { |i| "#{i}\n" }.join
-      end
-    end
+  def list(items, mode = :rows, option = nil)
+    ListRenderer.new(items, mode, option, self).render
   end
 
   #
@@ -612,27 +285,31 @@ class HighLine
   # ends with a space or tab character, a newline will not be appended (output
   # will be flush()ed).  All other cases are passed straight to Kernel.puts().
   #
-  # The _statement_ parameter is processed as an ERb template, supporting
-  # embedded Ruby code.  The template is evaluated with a binding inside
-  # the HighLine instance, providing easy access to the ANSI color constants
-  # and the HighLine.color() method.
+  # The _statement_ argument is processed as an ERb template, supporting
+  # embedded Ruby code.  The template is evaluated within a HighLine
+  # instance's binding for providing easy access to the ANSI color constants
+  # and the HighLine#color() method.
   #
-  def say( statement )
-    statement = format_statement(statement)
-    return unless statement.length > 0
+  def say(statement)
+    statement = render_statement(statement)
+    return if statement.empty?
 
-    out = (indentation+statement).encode(Encoding.default_external, { :undef => :replace  } )
+    statement = (indentation+statement)
 
     # Don't add a newline if statement ends with whitespace, OR
     # if statement ends with whitespace before a color escape code.
     if /[ \t](\e\[\d+(;\d+)*m)?\Z/ =~ statement
-      @output.print(out)
-      @output.flush
+      output.print(statement)
+      output.flush
     else
-      @output.puts(out)
+      output.puts(statement)
     end
   end
 
+  def render_statement(statement)
+    Statement.new(statement, self).to_s
+  end
+
   #
   # Set to an integer value to cause HighLine to wrap output lines at the
   # indicated character limit.  When +nil+, the default, no wrapping occurs.  If
@@ -657,7 +334,7 @@ class HighLine
   # Outputs indentation with current settings
   #
   def indentation
-    return ' '*@indent_size*@indent_level
+    ' '*@indent_size*@indent_level
   end
 
   #
@@ -666,20 +343,17 @@ class HighLine
   def indent(increase=1, statement=nil, multiline=nil)
     @indent_level += increase
     multi = @multi_indent
-    @multi_indent = multiline unless multiline.nil?
+    @multi_indent ||= multiline
     begin
-        if block_given?
-            yield self
-        else
-            say(statement)
-        end
-    rescue
-        @multi_indent = multi
-        @indent_level -= increase
-        raise
+      if block_given?
+        yield self
+      else
+        say(statement)
+      end
+    ensure
+      @multi_indent = multi
+      @indent_level -= increase
     end
-    @multi_indent = multi
-    @indent_level -= increase
   end
 
   #
@@ -695,7 +369,7 @@ class HighLine
   #
   def output_cols
     return 80 unless @output.tty?
-    terminal_size.first
+    terminal.terminal_size.first
   rescue
     return 80
   end
@@ -706,105 +380,37 @@ class HighLine
   #
   def output_rows
     return 24 unless @output.tty?
-    terminal_size.last
+    terminal.terminal_size.last
   rescue
     return 24
   end
 
-  private
-
-  def format_statement statement
-    statement = String(statement || "").dup
-    return statement unless statement.length > 0
-
-    template  = ERB.new(statement, nil, "%")
-    statement = template.result(binding)
-
-    statement = wrap(statement) unless @wrap_at.nil?
-    statement = page_print(statement) unless @page_at.nil?
-
-    # 'statement' is encoded in US-ASCII when using ruby 1.9.3(-p551)
-    # 'indentation' is correctly encoded (same as default_external encoding)
-    statement = statement.force_encoding(Encoding.default_external)
-
-    statement = statement.gsub(/\n(?!$)/,"\n#{indentation}") if @multi_indent
-
-    statement
+  def puts(*args)
+    @output.puts(*args)
   end
 
   #
-  # A helper method for sending the output stream and error and repeat
-  # of the question.
+  # Creates a new HighLine instance with the same options
   #
-  def explain_error( error )
-    say(@question.responses[error]) unless error.nil?
-    if @question.responses[:ask_on_error] == :question
-      say(@question)
-    elsif @question.responses[:ask_on_error]
-      say(@question.responses[:ask_on_error])
-    end
+  def new_scope
+    self.class.new(@input, @output, @wrap_at, @page_at, @indent_size, @indent_level)
   end
 
+  private
+
   #
-  # Collects an Array/Hash full of answers as described in
-  # HighLine::Question.gather().
-  #
-  # Raises EOFError if input is exhausted.
+  # A helper method for sending the output stream and error and repeat
+  # of the question.
   #
-  def gather(  )
-    original_question = @question
-    original_question_string = @question.question
-    original_gather = @question.gather
-
-    verify_match = @question.verify_match
-    @question.gather = false
-
-    begin   # when verify_match is set this loop will repeat until unique_answers == 1
-      @answers          = [ ]
-      @gather = original_gather
-      original_question.question = original_question_string
-
-      case @gather
-      when Integer
-        @answers << ask(@question)
-        @gather  -= 1
-
-        original_question.question = ""
-        until @gather.zero?
-          @question =  original_question
-          @answers  << ask(@question)
-          @gather   -= 1
-        end
-      when ::String, Regexp
-        @answers << ask(@question)
-
-        original_question.question = ""
-        until (@gather.is_a?(::String) and @answers.last.to_s == @gather) or
-            (@gather.is_a?(Regexp) and @answers.last.to_s =~ @gather)
-          @question =  original_question
-          @answers  << ask(@question)
-        end
-
-        @answers.pop
-      when Hash
-        @answers = { }
-        @gather.keys.sort.each do |key|
-          @question     = original_question
-          @key          = key
-          @answers[key] = ask(@question)
-        end
-      end
-
-      if verify_match && (unique_answers(@answers).size > 1)
-        @question =  original_question
-        explain_error(:mismatch)
-      else
-        verify_match = false
-      end
-
-    end while verify_match
+  def explain_error(error, question)
+    say(question.responses[error]) if error
+    say(question.ask_on_error_msg)
+  end
 
-    original_question.verify_match ? @answer : @answers
+  # Adds a layer of scope (new_scope) to ask a question inside a
+  # question, without destroying instance data
+  def confirm(question)
+    new_scope.agree(question.confirm_question(self))
   end
 
   #
@@ -812,10 +418,14 @@ class HighLine
   # for finding whether a list of answers match or differ
   # from each other.
   #
-  def unique_answers(list = @answers)
+  def unique_answers(list)
     (list.respond_to?(:values) ? list.values : list).uniq
   end
 
+  def last_answer(answers)
+    answers.respond_to?(:values) ? answers.values.last : answers.last
+  end
+
   #
   # Read a line of input from the input stream and process whitespace as
   # requested by the Question object.
@@ -825,224 +435,92 @@ class HighLine
   #
   # Raises EOFError if input is exhausted.
   #
-  def get_line(  )
-    if @question.readline
-      require "readline"    # load only if needed
-
-      # capture say()'s work in a String to feed to readline()
-      old_output = @output
-      @output    = StringIO.new
-      say(@question)
-      question = @output.string
-      @output  = old_output
-
-      # prep auto-completion
-      Readline.completion_proc = lambda do |string|
-        @question.selection.grep(/\A#{Regexp.escape(string)}/)
-      end
+  def get_line(question)
+    terminal.get_line(question, self)
+  end
 
-      # work-around ugly readline() warnings
-      old_verbose = $VERBOSE
-      $VERBOSE    = nil
-      raw_answer  = Readline.readline(question, true)
-      if raw_answer.nil?
-        if @@track_eof
-          raise EOFError, "The input stream is exhausted."
-        else
-          raw_answer = String.new # Never return nil
+  def get_response_line_mode(question)
+    if question.echo == true and !question.limit
+      get_line(question)
+    else
+      line = ""
+
+      terminal.raw_no_echo_mode_exec do
+        while character = terminal.get_character
+          break if character == "\n" or character == "\r"
+
+          # honor backspace and delete
+          if character == "\b"
+            chopped = line.chop!
+            output_erase_char if chopped and question.echo
+          else
+            line << character
+            @output.print(line[-1]) if question.echo == true
+            @output.print(question.echo) if question.echo and question.echo != true
+          end
+
+          @output.flush
+
+          break if question.limit and line.size == question.limit
         end
       end
-      answer      = @question.change_case(
-                        @question.remove_whitespace(raw_answer))
-      $VERBOSE    = old_verbose
 
-      answer
-    else
-      if JRUBY
-        statement = format_statement(@question)
-        raw_answer = @java_console.readLine(statement, nil)
-
-        raise EOFError, "The input stream is exhausted." if raw_answer.nil? and
-                                                            @@track_eof
+      if question.overwrite
+        @output.print("\r#{HighLine.Style(:erase_line).code}")
+        @output.flush
       else
-        raise EOFError, "The input stream is exhausted." if @@track_eof and
-                                                            @input.eof?
-        raw_answer = @input.gets
+        say("\n")
       end
 
-      @question.change_case(@question.remove_whitespace(raw_answer))
+      question.format_answer(line)
     end
   end
 
-  #
-  # Return a line or character of input, as requested for this question.
-  # Character input will be returned as a single character String,
-  # not an Integer.
-  #
-  # This question's _first_answer_ will be returned instead of input, if set.
-  #
-  # Raises EOFError if input is exhausted.
-  #
-  def get_response(  )
-    return @question.first_answer if @question.first_answer?
-
-    if @question.character.nil?
-      if @question.echo == true and @question.limit.nil?
-        get_line
-      else
-        raw_no_echo_mode
-
-        line            = "".encode(Encoding::BINARY)
-        backspace_limit = 0
-        begin
-
-          while character = get_character(@input)
-            # honor backspace and delete
-            if character == 127 or character == 8
-              line = line.force_encoding(Encoding.default_external)
-              line.slice!(-1, 1)
-              backspace_limit -= 1
-              line = line.force_encoding(Encoding::BINARY)
-            else
-              line << character.chr
-              backspace_limit = line.dup.force_encoding(Encoding.default_external).size
-            end
-            # looking for carriage return (decimal 13) or
-            # newline (decimal 10) in raw input
-            break if character == 13 or character == 10
-            if @question.echo != false
-              if character == 127 or character == 8
-                # only backspace if we have characters on the line to
-                # eliminate, otherwise we'll tromp over the prompt
-                if backspace_limit >= 0 then
-                  @output.print("\b#{HighLine.Style(:erase_char).code}")
-                else
-                    # do nothing
-                end
-              else
-                line_with_next_char_encoded = line.dup.force_encoding(Encoding.default_external)
-                # For multi-byte character, does this
-                #   last character completes the character?
-                # Then print it.
-                if line_with_next_char_encoded.valid_encoding?
-                  if @question.echo == true
-                    @output.print(line_with_next_char_encoded[-1])
-                  else
-                    @output.print(@question.echo)
-                  end
-                end
-              end
-              @output.flush
-            end
-            break if @question.limit and line.size == @question.limit
-          end
-        ensure
-          restore_mode
-        end
-        if @question.overwrite
-          @output.print("\r#{HighLine.Style(:erase_line).code}")
-          @output.flush
-        else
-          say("\n")
-        end
-
-        @question.change_case(@question.remove_whitespace(line.force_encoding(Encoding.default_external)))
-      end
-    else
-      if JRUBY #prompt has not been shown
-        say @question
-      end
+  def output_erase_char
+    @output.print("\b#{HighLine.Style(:erase_char).code}")
+  end
 
-      raw_no_echo_mode
-      begin
-        if @question.character == :getc
-          response = @input.getbyte.chr
-        else
-          response = get_character(@input).chr
-          if @question.overwrite
-            @output.print("\r#{HighLine.Style(:erase_line).code}")
-            @output.flush
-          else
-            echo = if @question.echo == true
-              response
-            elsif @question.echo != false
-              @question.echo
-            else
-              ""
-            end
-            say("#{echo}\n")
-          end
-        end
-      ensure
-        restore_mode
-      end
-      @question.change_case(response)
+  def get_response_getc_mode(question)
+    terminal.raw_no_echo_mode_exec do
+      response = @input.getc
+      question.format_answer(response)
     end
   end
 
-  #
-  # Page print a series of at most _page_at_ lines for _output_.  After each
-  # page is printed, HighLine will pause until the user presses enter/return
-  # then display the next page of data.
-  #
-  # Note that the final page of _output_ is *not* printed, but returned
-  # instead.  This is to support any special handling for the final sequence.
-  #
-  def page_print( output )
-    lines = output.lines.to_a
-    while lines.size > @page_at
-      @output.puts lines.slice!(0...@page_at).join
-      @output.puts
-      # Return last line if user wants to abort paging
-      return "...\n#{lines.last}" unless continue_paging?
+  def get_response_character_mode(question)
+    terminal.raw_no_echo_mode_exec do
+      response = terminal.get_character
+      if question.overwrite
+        erase_current_line
+      else
+        echo = get_echo(question, response)
+        say("#{echo}\n")
+      end
+      question.format_answer(response)
     end
-    return lines.join
   end
 
-  #
-  # Ask user if they wish to continue paging output. Allows them to type "q" to
-  # cancel the paging process.
-  #
-  def continue_paging?
-    command = HighLine.new(@input, @output).ask(
-      "-- press enter/return to continue or q to stop -- "
-    ) { |q| q.character = true }
-    command !~ /\A[qQ]\Z/  # Only continue paging if Q was not hit.
+  def erase_current_line
+    @output.print("\r#{HighLine.Style(:erase_line).code}")
+    @output.flush
   end
 
-  #
-  # Wrap a sequence of _lines_ at _wrap_at_ characters per line.  Existing
-  # newlines will not be affected by this process, but additional newlines
-  # may be added.
-  #
-  def wrap( text )
-    wrapped = [ ]
-    text.each_line do |line|
-      # take into account color escape sequences when wrapping
-      wrap_at = @wrap_at + (line.length - actual_length(line))
-      while line =~ /([^\n]{#{wrap_at + 1},})/
-        search  = $1.dup
-        replace = $1.dup
-        if index = replace.rindex(" ", wrap_at)
-          replace[index, 1] = "\n"
-          replace.sub!(/\n[ \t]+/, "\n")
-          line.sub!(search, replace)
-        else
-          line[$~.begin(1) + wrap_at, 0] = "\n"
-        end
-      end
-      wrapped << line
+  def get_echo(question, response)
+    if question.echo == true
+      response
+    elsif question.echo != false
+      question.echo
+    else
+      ""
     end
-    return wrapped.join
   end
 
-  #
-  # Returns the length of the passed +string_with_escapes+, minus and color
-  # sequence escapes.
-  #
-  def actual_length( string_with_escapes )
-    string_with_escapes.to_s.gsub(/\e\[\d{1,2}m/, "").length
+  public :get_response_character_mode, :get_response_line_mode
+  public :get_response_getc_mode
+
+  def actual_length(text)
+    Wrapper.actual_length text
   end
 end
 
-require "highline/string_extensions"
+require "highline/string"