highline 0.2.0

data/CHANGELOG

@@ -0,0 +1,30 @@
+= Change Log
+
+Below is a complete listing of changes for each revision of HighLine.
+
+== 0.2.0
+
+* Added Unit Tests to cover an already fixed output bug in the future.
+* Added Rakefile and setup test action (default).
+* Renamed HighLine::Answer to HighLine::Question to better illustrate its role.
+* Renamed fetch_line() to get_response() to better define its goal.
+* Simplified explain_error in terms of the Question object.
+* Renamed accept?() to in_range?() to better define purpose.
+* Reworked valid?() into valid_answer?() to better fit Question object.
+* Reworked <tt>@member</tt> into <tt>@in</tt>, to make it easier to remember and
+  switched implementation to include?().
+* Added range checks for @above and @below.
+* Fixed the bug causing ask() to swallow NoMethodErrors.
+* Rolled ask_on_error() into responses.
+* Redirected imports to Kernel from Object.
+* Added support for <tt>validate lambda { ... }</tt>.
+* Added default answer support.
+* Fixed bug that caused ask() to die with an empty question.
+* Added complete documentation.
+* Improve the implemetation of agree() to be the intended "yes" or "no" only
+  question.
+
+== 0.1.0
+
+* Initial release as the solution to
+  {Ruby Quiz #29}[http://www.rubyquiz.com/quiz29.html].

data/INSTALL

@@ -0,0 +1,10 @@
+= Installing the Gem
+
+HighLine is intended to be installed via the
+RubyGems[http://rubyforge.org/projects/rubygems/] system.  To get the latest
+version, simply enter the following into your command prompt:
+
+	sudo gem install highline
+
+You must have RubyGems[http://rubyforge.org/projects/rubygems/] installed for
+the above to work.

data/LICENSE

@@ -0,0 +1,7 @@
+= License Terms
+
+Distributed under the
+{Ruby software license}[http://www.ruby-lang.org/en/LICENSE.txt] by
+James Edward Gray II.
+
+Please email James[mailto:james@grayproductions.net] with any questions.

data/README

@@ -0,0 +1,31 @@
+= Read Me
+
+by James Edward Gray II
+
+== Description
+
+Welcome to HighLine.
+
+This library was designed to ease the tedious tasks of doing console input and
+output with low-level methods like gets() and puts().  This library provides a
+robust system to requesting data from a user, without needing to code all the
+error checking and validation rules and without needing to convert the typed
+Strings into what your program really needs.  Just tell HighLine what you're
+after, and leg it do all the leg work.
+
+== Documentation
+
+See HighLine and HighLine::Question for documentation.
+
+== Examples
+
+See the examples/ directory of this project for code examples.
+
+== Installing
+
+See the INSTALL file for instructions.
+
+== Questions
+
+Feel free to email {James Edward Gray II}[mailto:james@grayproductions.net] with
+any questions.

data/Rakefile

@@ -0,0 +1,52 @@
+require "rake/rdoctask"
+require "rake/testtask"
+require "rake/gempackagetask"
+
+require "rubygems"
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+	test.libs << "test"
+	test.test_files = [ "test/ts_all.rb" ]
+	test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+	rdoc.main = "README"
+	rdoc.rdoc_files.include( "README", "INSTALL",
+	                         "TODO", "CHANGELOG",
+	                         "LICENSE", "lib/" )
+	rdoc.rdoc_dir = "doc/html"
+	rdoc.title = "HighLine Documentation"
+end
+
+spec = Gem::Specification.new do |spec|
+	spec.name = "highline"
+	spec.version = "0.2.0"
+	spec.platform = Gem::Platform::RUBY
+	spec.summary = "HighLine is a high-level line oriented console interface."
+	spec.files = Dir.glob("{examples,lib,test}/**/*.rb").
+	                 delete_if { |item| item.include?("CVS") } + ["Rakefile"]
+	spec.test_suite_file = "test/ts_all.rb"
+	spec.has_rdoc = true
+	spec.extra_rdoc_files = %w{README INSTALL TODO CHANGELOG LICENSE}
+	spec.rdoc_options << '--title' << 'HighLine Documentation' <<
+	                     '--main'  << 'README'
+	spec.require_path = 'lib'
+	spec.autorequire = "highline"
+	spec.author = "James Edward Gray II"
+	spec.email = "james@grayproductions.net"
+	spec.rubyforge_project = "highline"
+	spec.homepage = "http://highline.rubyforge.org"
+	spec.description = <<END_DESC
+A "high-level line oriented" input/output library that grew out of my solution
+to Ruby Quiz #29. This library attempts to make standard console input and
+output robust and painless.
+END_DESC
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+	pkg.need_zip = true
+	pkg.need_tar = true
+end

data/TODO

@@ -0,0 +1,16 @@
+= To Do List
+
+The following is a list of planned expansions for HighLine, in no particular
+order.
+
+* Expose response replacements for user code strings.
+* Support character oriented input.
+* Support <tt>ask(..., Array)</tt>, better than the current
+  <tt>ask(..., lambda { |arr| arr.split(",") })</tt> or similar.
+* Support <tt>ask(..., Hash)</tt>.
+* Provide for <tt>ask(..., MyClass)</tt>.
+* Add ANSI color support to say().
+* Add word wrap support to say().
+* Allow user code to specify whitespace handling for <tt>@input</tt>
+  (chomp(), strip(), etc.).
+* Support install with setup.rb.

data/examples/basic_usage.rb

@@ -0,0 +1,51 @@
+#!/usr/local/bin/ruby -w
+
+# basic_usage.rb
+#
+#  Created by James Edward Gray II on 2005-04-28.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "rubygems"
+require "highline/import"
+require "yaml"
+
+contacts = [ ]
+
+begin
+	entry = Hash.new
+	
+	# basic output
+	say("Enter a contact:")
+
+	# basic input
+	entry[:name]        = ask("Name?  (last, first)  ") do |q|
+		q.validate = /\A\w+, ?\w+\Z/
+	end
+	entry[:company]     = ask("Company?  ") { |q| q.default = "none" }
+	entry[:address]     = ask("Address?  ")
+	entry[:city]        = ask("City?  ")
+	entry[:state]       = ask("State?  ") { |q| q.validate = /\A[A-Z]{2}\Z/ }
+	entry[:zip]         = ask("Zip?  ") do |q|
+		q.validate = /\A\d{5}(?:-?\d{4})?\Z/
+	end
+	entry[:phone]       = ask( "Phone?  ",
+	                           lambda { |p| p.delete("^0-9").
+	                                          sub(/\A(\d{3})/, '(\1) ').
+	                                          sub(/(\d{4})\Z/, '-\1') } ) do |q|
+		q.validate              = lambda { |p| p.delete("^0-9").length == 10 }
+		q.responses[:not_valid] = "Enter a phone numer with area code."
+	end
+	entry[:age]         = ask("Age?  ", Integer) { |q| q.in = 0..105 }
+	entry[:birthday]    = ask("Birthday?  ", Date)
+	entry[:interests]   = ask( "Interests?  (comma separated list)  ",
+	                           lambda { |str| str.split(/,\s*/) } )
+	entry[:description] = ask("Enter a description for this contact.")
+
+	contacts << entry
+# shortcut for yes and no questions
+end while agree("Enter another contact?  ")
+
+if agree("Save these contacts?  ")
+	file_name = ask("Enter a file name:  ") { |q| q.validate = /\A\w+\Z/ }
+	File.open("#{file_name}.yaml", "w") { |file| YAML.dump(contacts, file) }
+end

data/lib/highline.rb

@@ -0,0 +1,125 @@
+#!/usr/local/bin/ruby -w
+
+# highline.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+#
+# See HighLine for documentation.
+
+require "highline/question"
+
+#
+# A HighLine object is a "high-level line oriented" shell over an input and an 
+# output stream.  HighLine simplifies common console interaction, effectively
+# replacing puts() and gets().  User code can simply specify the question to ask
+# and any details about user interaction, then leave the rest of the work to
+# HighLine.  When HighLine.ask() returns, you'll have to answer you requested,
+# even if HighLine had to ask many times, validate results, perform range
+# 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
+	
+	# Create an instance of HighLine, connected to the streams _input_
+	# and _output_.
+	def initialize( input = $stdin, output = $stdout )
+		@input  = input
+		@output = output
+	end
+	
+	#
+	# A shortcut to HighLine.ask() a question that only accepts "yes" or "no"
+	# answers ("y" and "n" are allowed) and returns +true+ or +false+
+	# (+true+ for "yes").
+	#
+	def agree( yes_or_no_question )
+		ask(yes_or_no_question, lambda { |yn| yn.downcase[0] == ?y}) do |q|
+			q.validate                 = /\Ay(?:es)?|no?\Z/i
+			q.responses[:not_valid]    = 'Please enter "yes" or "no".'
+			q.responses[:ask_on_error] = :question
+		end
+	end
+	
+	#
+	# This method is the primary interface for user input.  Just provide a
+	# _question_ to ask the user, the _answer_type_ you want returned, and
+	# optionally a code block setting up details of how you want the question
+	# handled.  See HighLine.say() for details on the format of _question_, and
+	# HighLine::Question for more information about _answer_type_ and what's
+	# valid in the code block.
+	#
+	def ask( question, answer_type = String, &details ) # :yields: question
+		question = Question.new(question, answer_type, &details)
+		
+		say(question)
+		begin
+			answer = question.answer_or_default(get_response)
+			unless question.valid_answer?(answer)
+				explain_error(question, :not_valid)
+				raise QuestionError
+			end
+			
+			answer = question.convert(answer)
+			
+			if question.in_range?(answer)
+				answer
+			else
+				explain_error(question, :not_in_range)
+				raise QuestionError
+			end
+		rescue QuestionError
+			retry
+		rescue ArgumentError
+			explain_error(question, :invalid_type)
+			retry
+		rescue NameError
+			raise if $!.is_a?(NoMethodError)
+			explain_error(question, :ambiguous_completion)
+			retry
+		end
+	end
+	
+	#
+	# The basic output method for HighLine objects.  If the provided _statement_
+	# 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().
+	#
+	def say( statement )
+		statement = statement.to_s
+		return unless statement.length > 0
+		
+		if statement[-1, 1] == " " or statement[-1, 1] == "\t"
+			@output.print(statement)
+			@output.flush	
+		else
+			@output.puts(statement)
+		end
+	end
+	
+	private
+	
+	#
+	# A helper method for sending the output stream and error and repeat
+	# of the question.
+	#
+	def explain_error( question, error )
+		say(question.responses[error])
+		if question.responses[:ask_on_error] == :question
+			say(question)
+		elsif question.responses[:ask_on_error]
+			say(question.responses[:ask_on_error])
+		end
+	end
+	
+	#
+	# Read a line of input from the input stream, chomp()ing any newline
+	# characters.
+	#
+	def get_response(  )
+		@input.gets.chomp
+	end
+end

data/lib/highline/import.rb

@@ -0,0 +1,25 @@
+#!/usr/local/bin/ruby -w
+
+# import.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "highline"
+require "forwardable"
+
+$terminal = HighLine.new
+
+#
+# <tt>require "highline/import"</tt> adds shorcut methods to Kernel, making
+# agree(), ask(), and say() globally available.  This is handy for quick and
+# dirty input and output.  These methods use the HighLine object in the global
+# variable <tt>$terminal</tt>, which is initialized to used <tt>$stdin</tt> and
+# <tt>$stdout</tt> (you are free to change this).  Otherwise, these methods are
+# identical to their HighLine counterparts, see that class for detailed
+# explinations.
+#
+module Kernel
+	extend Forwardable
+	def_delegators :$terminal, :agree, :ask, :say
+end

data/lib/highline/question.rb

@@ -0,0 +1,208 @@
+#!/usr/local/bin/ruby -w
+
+# question.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+require "optparse"
+require "date"
+
+class HighLine
+	#
+	# Question objects contain all the details of a single invocation of
+	# HighLine.ask().  The object is initialized by the parameters passed to
+	# HighLine.ask() and then queried to make sure each step of the input
+	# process is handled according to the users wishes.
+	#
+	class Question
+		#
+		# Create an instance of HighLine::Question.  Expects a _question_ to ask
+		# (can be <tt>""</tt>) and an _answer_type_ to convert the answer to.
+		# The _answer_type_ parameter must be a type recongnized by
+		# Question.convert(). If given, a block is yeilded the new Question
+		# object to allow custom initializaion.
+		#
+		def initialize( question, answer_type )
+			# initialize instance data
+			@question    = question
+			@answer_type = answer_type
+			
+			@default      = nil
+			@validate     = nil
+			@above        = nil
+			@below        = nil
+			@in           = nil
+			@responses     = Hash.new
+			
+			# allow block to override settings
+			yield self if block_given?
+
+			# finalize responses based on settings
+			append_default unless default.nil?
+			@responses = { :ambiguous_completion =>
+			                   "Ambiguous choice.  " +
+			                   "Please choose one of #{@answer_type.inspect}.",
+		                   :ask_on_error         =>
+		                       "?  ",
+			               :invalid_type         =>
+			                   "You must enter a valid #{@answer_type}.",
+		                   :not_in_range         =>
+		                       "Your answer isn't within the expected range " +
+		                       "(#{expected_range}).",
+			               :not_valid            =>
+			                   "Your answer isn't valid (must match " +
+			                   "#{@validate.inspect})." }.merge(@responses)
+		end
+		
+		# Used to provide a default answer to this question.
+		attr_accessor :default
+		#
+		# If set to a Regexp, the answer must match (before type conversion).
+		# Can also be set to a Proc which will be called with the provided
+		# answer to validate with a +true+ or +false+ return.
+		#
+		attr_accessor :validate
+		# Used to control range checks for answer.
+		attr_accessor :above, :below
+		# If set, answer must pass an include?() check on this object.
+		attr_accessor :in
+		#
+		# A Hash that stores the various responses used by HighLine to notify
+		# the user.  The currently used responses and their purpose are as
+		# follows:
+		#
+		# <tt>:ambiguous_completion</tt>::  Used to notify the user of an
+		#                                   ambiguous answer the auto-completion
+		#                                   system cannot resolve.
+		# <tt>:ask_on_error</tt>::          This is the question that will be
+		#                                   redisplayed to the user in the event
+		#                                   of an error.  Can be set to
+		#                                   <tt>:question</tt> to repeat the
+		#                                   original question.
+		# <tt>:invalid_type</tt>::          The error message shown when a type
+		#                                   conversion fails.
+		# <tt>:not_in_range</tt>::          Used to notify the user that a
+		#                                   provided answer did not satisfy
+		#                                   the range requirement tests.
+		# <tt>:not_valid</tt>::             The error message shown when
+		#                                   validation checks fail.
+		#
+		attr_reader :responses
+		
+		#
+		# Transforms the given _answer_string_ into the expected type for this
+		# Question.  Currently supported conversions are:
+		#
+		# <tt>[...]</tt>::        Answer must be a member of the passed Array. 
+		#                         Auto-completion is used to expand partial
+		#                         answers.
+		# <tt>lambda {...}</tt>:: Answer is passed to lambda for conversion.
+		# Date::                  Date.parse() is called with answer.
+		# DateTime::              DateTime.parse() is called with answer.
+		# Float::                 Answer is converted with Kernel.Float().
+		# Integer::               Answer is converted with Kernel.Integer().
+		# +nil+::                 Answer is left in String format.
+		# String::                Answer is converted with Kernel.String().
+		# Regexp::                Answer is fed to Regexp.new().
+		# Symbol::                The method to_sym() is called on answer and
+		#                         the result returned.
+		#
+		# This method throws ArgumentError, if the conversion cannot be
+		# completed for any reason.
+		# 
+		def convert( answer_string )
+			if @answer_type.nil?
+				answer_string
+			elsif [Float, Integer, String].include?(@answer_type)
+				Kernel.send(@answer_type.to_s.to_sym, answer_string)
+			elsif @answer_type == Symbol
+				answer_string.to_sym
+			elsif @answer_type == Regexp
+				Regexp.new(answer_string)
+			elsif @answer_type.is_a?(Array)
+				# cheating, using OptionParser's Completion module
+				@answer_type.extend(OptionParser::Completion)
+				@answer_type.complete(answer_string).last
+			elsif [Date, DateTime].include?(@answer_type)
+				@answer_type.parse(answer_string)
+			elsif @answer_type.is_a?(Proc)
+				@answer_type[answer_string]
+			end
+		end
+		
+		#
+		# Returns the provided _answer_string_ or the default answer for this
+		# Question if a default was set and the answer is empty.
+		#
+		def answer_or_default( answer_string )
+			if answer_string.length == 0 and not @default.nil?
+				@default
+			else
+				answer_string
+			end
+		end
+		
+		#
+		# Returns +true+ if the _answer_object_ is greater than the _above_
+		# attribute, less than the _below_ attribute and included?()ed in the
+		# _in_ attribute.  Otherwise, +false+ is returned.  Any +nil+ attributes
+		# are not checked.
+		#
+		def in_range?( answer_object )
+			(@above.nil? or answer_object > @above) and
+			(@below.nil? or answer_object < @below) and
+			(@in.nil? or @in.include?(answer_object))
+		end
+		
+		# Stringifies the question to be asked.
+		def to_s(  )
+			@question
+		end
+
+		#
+		# Returns +true+ if the provided _answer_string_ is accepted by the 
+		# _validate_ attribute or +false+ if it's not.
+		#
+		def valid_answer?( answer_string )
+			@validate.nil? or 
+			(@validate.is_a?(Regexp) and answer_string =~ @validate) or
+			(@validate.is_a?(Proc)   and @validate[answer_string])
+		end
+		
+		private
+		
+		#
+		# Adds the default choice to the end of question between <tt>|...|</tt>.
+		# Trailing whitespace is preserved so the function of HighLine.say() is
+		# not affected.
+		#
+		def append_default(  )
+			if @question =~ /([\t ]+)\Z/
+				@question << "|#{@default}|#{$1}"
+			elsif @question == ""
+				@question << "|#{@default}|  "
+			elsif @question[-1, 1] == "\n"
+				@question[-2, 0] =  "  |#{@default}|"
+			else
+				@question << "  |#{@default}|"
+			end
+		end
+		
+		# Returns a english explination of the current range settings.
+		def expected_range(  )
+			expected = [ ]
+
+			expected << "above #{@above}" unless @above.nil?
+			expected << "below #{@below}" unless @below.nil?
+			expected << "included in #{@in.inspect}" unless @in.nil?
+
+			case expected.size
+			when 0 then ""
+			when 1 then expected.first
+			when 2 then expected.join(" and ")
+			else        expected[0..-2].join(", ") + ", and #{expected.last}"
+			end
+		end
+	end
+end

data/test/tc_highline.rb

@@ -0,0 +1,301 @@
+#!/usr/local/bin/ruby -w
+
+# tc_highline.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+$test_lib_dir ||= File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift($test_lib_dir) unless $:.include?($test_lib_dir)
+
+require "test/unit"
+
+require "highline"
+require "stringio"
+
+class TestHighLine < Test::Unit::TestCase
+	def setup
+		@input    = StringIO.new
+		@output   = StringIO.new
+		@terminal = HighLine.new(@input, @output)	
+	end
+	
+	def test_agree
+		@input << "y\nyes\nYES\nHell no!\nNo\n"
+		@input.rewind
+
+		assert_equal(true, @terminal.agree("Yes or no?  "))
+		assert_equal(true, @terminal.agree("Yes or no?  "))
+		assert_equal(true, @terminal.agree("Yes or no?  "))
+		assert_equal(false, @terminal.agree("Yes or no?  "))
+	end
+	
+	def test_ask
+		name = "James Edward Gray II"
+		@input << name << "\n"
+		@input.rewind
+
+		assert_equal(name, @terminal.ask("What is your name?  "))
+	end
+	
+	def test_defaults
+		@input << "\nNo Comment\n"
+		@input.rewind
+
+		answer = @terminal.ask("Are you sexually active?  ") do |q|
+			q.validate = /\Ay(?:es)?|no?|no comment\Z/i
+		end
+		assert_equal("No Comment", answer)
+
+		@input.truncate(@input.rewind)
+		@input << "\nYes\n"
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Are you sexually active?  ") do |q|
+			q.default  = "No Comment"
+			q.validate = /\Ay(?:es)?|no?|no comment\Z/i
+		end
+		assert_equal("No Comment", answer)
+		assert_equal( "Are you sexually active?  |No Comment|  ",
+		              @output.string )
+	end
+	
+	def test_empty
+		@input << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("") do |q|
+			q.default  = "yes"
+			q.validate = /\Ay(?:es)?|no?\Z/i
+		end
+		assert_equal("yes", answer)
+	end
+	
+	def test_range_requirements
+		@input << "112\n-541\n28\n"
+		@input.rewind
+
+		answer = @terminal.ask("Tell me your age.", Integer) do |q|
+			q.in = 0..105
+		end
+		assert_equal(28, answer)
+		assert_equal( "Tell me your age.\n" +
+		              "Your answer isn't within the expected range " +
+		              "(included in 0..105).\n" +
+		              "?  " +
+		              "Your answer isn't within the expected range " +
+		              "(included in 0..105).\n" +
+		              "?  ", @output.string )
+
+		@input.truncate(@input.rewind)
+		@input << "1\n-541\n28\n"
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Tell me your age.", Integer) do |q|
+			q.above = 3
+		end
+		assert_equal(28, answer)
+		assert_equal( "Tell me your age.\n" +
+		              "Your answer isn't within the expected range " +
+		              "(above 3).\n" +
+		              "?  " +
+		              "Your answer isn't within the expected range " +
+		              "(above 3).\n" +
+		              "?  ", @output.string )
+
+		@input.truncate(@input.rewind)
+		@input << "1\n28\n-541\n"
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Lowest numer you can think of?", Integer) do |q|
+			q.below = 0
+		end
+		assert_equal(-541, answer)
+		assert_equal( "Lowest numer you can think of?\n" +
+		              "Your answer isn't within the expected range " +
+		              "(below 0).\n" +
+		              "?  " +
+		              "Your answer isn't within the expected range " +
+		              "(below 0).\n" +
+		              "?  ", @output.string )
+
+		@input.truncate(@input.rewind)
+		@input << "1\n-541\n6\n"
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Enter a low even number:  ", Integer) do |q|
+			q.above = 0
+			q.below = 10
+			q.in    = [2, 4, 6, 8]
+		end
+		assert_equal(6, answer)
+		assert_equal( "Enter a low even number:  " +
+		              "Your answer isn't within the expected range " +
+		              "(above 0, below 10, and included in [2, 4, 6, 8]).\n" +
+		              "?  " +
+		              "Your answer isn't within the expected range " +
+		              "(above 0, below 10, and included in [2, 4, 6, 8]).\n" +
+		              "?  ", @output.string )
+	end
+	
+	def test_reask
+		number = 61676
+		@input << "Junk!\n" << number << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("Favorite number?  ", Integer)
+		assert_kind_of(Integer, number)
+		assert_instance_of(Fixnum, number)
+		assert_equal(number, answer)
+		assert_equal( "Favorite number?  " +
+		              "You must enter a valid Integer.\n" +
+		              "?  ", @output.string )
+
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Favorite number?  ", Integer) do |q|
+			q.responses[:ask_on_error] = :question
+			q.responses[:invalid_type] = "Not a valid number!"
+		end
+		assert_kind_of(Integer, number)
+		assert_instance_of(Fixnum, number)
+		assert_equal(number, answer)
+		assert_equal( "Favorite number?  " +
+		              "Not a valid number!\n" +
+		              "Favorite number?  ", @output.string )
+
+		@input.truncate(@input.rewind)
+		@input << "gen\ngene\n"
+		@input.rewind
+		@output.truncate(@output.rewind)
+
+		answer = @terminal.ask("Select a mode:  ", [:generate, :gentle])
+		assert_instance_of(Symbol, answer)
+		assert_equal(:generate, answer)
+		assert_equal("Select a mode:  " +
+		             "Ambiguous choice.  " +
+		             "Please choose one of [:generate, :gentle].\n" +
+		             "?  ", @output.string)
+	end
+	
+	def test_say
+		@terminal.say("This will have a newline.")
+		assert_equal("This will have a newline.\n", @output.string)
+
+		@output.truncate(@output.rewind)
+
+		@terminal.say("This will also have one newline.\n")
+		assert_equal("This will also have one newline.\n", @output.string)
+
+		@output.truncate(@output.rewind)
+
+		@terminal.say("This will not have a newline.  ")
+		assert_equal("This will not have a newline.  ", @output.string)
+	end
+
+	def test_type_conversion
+		number = 61676
+		@input << number << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("Favorite number?  ", Integer)
+		assert_kind_of(Integer, answer)
+		assert_instance_of(Fixnum, answer)
+		assert_equal(number, answer)
+		
+		@input.truncate(@input.rewind)
+		number = 1_000_000_000_000_000_000_000_000_000_000
+		@input << number << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("Favorite number?  ", Integer)
+		assert_kind_of(Integer, answer)
+		assert_instance_of(Bignum, answer)
+		assert_equal(number, answer)
+
+		@input.truncate(@input.rewind)
+		number = 10.5002
+		@input << number << "\n"
+		@input.rewind
+
+		answer = @terminal.ask( "Favorite number?  ",
+								lambda { |n| n.to_f.abs.round } )
+		assert_kind_of(Integer, answer)
+		assert_instance_of(Fixnum, answer)
+		assert_equal(11, answer)
+
+		@input.truncate(@input.rewind)
+		animal = :dog
+		@input << animal << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("Favorite animal?  ", Symbol)
+		assert_instance_of(Symbol, answer)
+		assert_equal(animal, answer)
+
+		@input.truncate(@input.rewind)
+		@input << "6/16/76\n"
+		@input.rewind
+
+		answer = @terminal.ask("Enter your birthday.", Date)
+		assert_instance_of(Date, answer)
+		assert_equal(16, answer.day)
+		assert_equal(6, answer.month)
+		assert_equal(76, answer.year)
+
+		@input.truncate(@input.rewind)
+		pattern = "^yes|no$"
+		@input << pattern << "\n"
+		@input.rewind
+
+		answer = @terminal.ask("Give me a pattern to match with:  ", Regexp)
+		assert_instance_of(Regexp, answer)
+		assert_equal(/#{pattern}/, answer)
+
+		@input.truncate(@input.rewind)
+		@input << "gen\n"
+		@input.rewind
+
+		answer = @terminal.ask("Select a mode:  ", [:generate, :run])
+		assert_instance_of(Symbol, answer)
+		assert_equal(:generate, answer)
+	end
+	
+	def test_validation
+		@input << "system 'rm -rf /'\n105\n0b101_001\n"
+		@input.rewind
+
+		answer = @terminal.ask("Enter a binary number:  ") do |q|
+			q.validate = /\A(?:0b)?[01_]+\Z/
+		end
+		assert_equal("0b101_001", answer)
+		assert_equal( "Enter a binary number:  " +
+		              "Your answer isn't valid " +
+		              "(must match /\\A(?:0b)?[01_]+\\Z/).\n" +
+		              "?  " +
+		              "Your answer isn't valid " +
+		              "(must match /\\A(?:0b)?[01_]+\\Z/).\n" +
+		              "?  ", @output.string )
+
+		@input.truncate(@input.rewind)
+		@input << "Gray II, James Edward\n" +
+		          "Gray, Dana Ann Leslie\n" +
+		          "Gray, James Edward\n"
+		@input.rewind
+
+		answer = @terminal.ask("Your name?  ") do |q|
+			q.validate = lambda do |name|
+				names = name.split(/,\s*/)
+				return false unless names.size == 2
+				return false if names.first =~ /\s/
+				names.last.split.size == 2
+			end
+		end
+		assert_equal("Gray, James Edward", answer)
+	end
+end

data/test/tc_import.rb

@@ -0,0 +1,28 @@
+#!/usr/local/bin/ruby -w
+
+# tc_import.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+$test_lib_dir ||= File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift($test_lib_dir) unless $:.include?($test_lib_dir)
+
+require "test/unit"
+
+require "highline/import"
+require "stringio"
+
+class TestImport < Test::Unit::TestCase
+	def test_import
+		assert_respond_to(self, :agree)
+		assert_respond_to(self, :ask)
+		assert_respond_to(self, :say)
+	end
+	
+	def test_redirection
+		$terminal = HighLine.new(nil, (output = StringIO.new))
+		say("Testing...")
+		assert_equal("Testing...\n", output.string)
+	end
+end

data/test/ts_all.rb

@@ -0,0 +1,14 @@
+#!/usr/local/bin/ruby -w
+
+# ts_all.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+
+$test_dir ||= File.dirname(__FILE__)
+$:.unshift($test_dir) unless $:.include?($test_dir)
+
+require "test/unit"
+
+require "tc_highline"
+require "tc_import"

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: highline
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2005-04-29
+summary: HighLine is a high-level line oriented console interface.
+require_paths: 
+  - lib
+email: james@grayproductions.net
+homepage: http://highline.rubyforge.org
+rubyforge_project: highline
+description: "A \"high-level line oriented\" input/output library that grew out of my solution
+  to Ruby Quiz #29. This library attempts to make standard console input and
+  output robust and painless."
+autorequire: highline
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - James Edward Gray II
+files: 
+  - examples/basic_usage.rb
+  - lib/highline.rb
+  - lib/highline/import.rb
+  - lib/highline/question.rb
+  - test/tc_highline.rb
+  - test/tc_import.rb
+  - test/ts_all.rb
+  - Rakefile
+  - README
+  - INSTALL
+  - TODO
+  - CHANGELOG
+  - LICENSE
+test_files: 
+  - test/ts_all.rb
+rdoc_options: 
+  - "--title"
+  - HighLine Documentation
+  - "--main"
+  - README
+extra_rdoc_files: 
+  - README
+  - INSTALL
+  - TODO
+  - CHANGELOG
+  - LICENSE
+executables: []
+extensions: []
+requirements: []
+dependencies: []