lilutils 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2011-02-08
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,22 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/lilutils.rb
+lib/lilutils/cli/cli.rb
+lib/lilutils/cli_entry.rb
+lib/lilutils/algo_test_utils/data_sets.rb
+lib/lilutils/algo_test_utils_entry.rb
+lib/lilutils/misc/misc.rb
+lib/lilutils/misc/pascal.rb
+lib/lilutils/misc_entry.rb
+bin/cli-demo
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_lilutils.rb
+test/algo_test_utils/data_sets_test.rb
+test/cli/cli_basic_test.rb
+test/misc/misc_pascal_test.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on lilutils, see http://lilutils.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,55 @@
+= lilutils
+
+* http://github.com:kedarmhaswade/lilutils.git
+
+== DESCRIPTION:
+
+Provides little utilities that are mainly intended for myself. Maybe someone else would find them useful?
+
+== FEATURES/PROBLEMS:
+
+* Provides a CLI module which provides a general purpose selection interface for command line interface.
+
+
+== SYNOPSIS:
+
+require 'lilutils/cli'
+
+yn = YesNo.new
+
+puts "You chose: #{yn.show}"
+
+See bin/cli-demo after the gem is installed.
+
+== REQUIREMENTS:
+
+* Ruby 1.9.2
+
+== INSTALL:
+
+* [sudo] gem install lilutils
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Kedar Mhaswade
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "lilutils"
+  gem.homepage = "http://github.com/kedarmhaswade/lilutils"
+  gem.license = "MIT"
+  gem.summary = %Q{Little utilities for everyone}
+  gem.description = %Q{Provides little utilties. It's a gem by a newbie, but I think it is quite useful. As of now, it provides a nicely abstracted out yes/no/cancel dialog box on a console.}
+  gem.email = "kedar.mhaswade@gmail.com"
+  gem.authors = ["Kedar Mhaswade"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lilutils #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/cli-demo

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'lilutils'
+CLI = LilUtils::CLI
+yn = CLI::NumberedOption.new(1, "Yes/No")
+ync = CLI::NumberedOption.new(2, "Yes/No/Cancel")
+list = CLI::NumberedOptions.new([yn, ync], 0, "Pick your pick for the demo: ", true)
+puts "You chose: #{list.show}"
+puts "Now opposite of the above"
+list = CLI::NumberedOptions.new([yn, ync], 1, "Just press Enter to see what happens", true)
+puts "You chose: #{list.show}"
+puts "Now special case of the above"
+yes_no = CLI::YesNo.new
+puts "You chose: #{yes_no.show}"
+puts "Liked it? Then use it!"
+sc = CLI::Option.new("Show code")
+ex = CLI::Option.new("Just exit")
+yn = CLI::OptionList.new([sc, ex], 0, "What do you want me to do?", true)
+choice = yn.show
+if choice == sc # show me code
+  puts "-----------------------------------------------------------------------"
+  File.open(__FILE__, "r") do |f|
+    f.readlines.each do |line|
+      puts line
+    end
+  puts "-----------------------------------------------------------------------"
+  end
+elsif choice == ex # just exit
+  puts "Bye!"
+  exit 0
+else
+  puts "Impossible!"
+end
+

data/lib/lilutils/algo_test_utils/data_sets.rb

@@ -0,0 +1,57 @@
+# Provides for code useful to test algorithms, do benchmarks etc. For example, you might be testing a sorting algorithm
+# and need 100_000 or 1_000_000 randomly generated (supposedly unsorted) strings. Of course, you are not going to test
+# your algorithm with ten or hundred strings or numbers, right?
+module LilUtils
+  module AlgoTestUtils
+    module DataSets
+      ALPHABET = ('a'..'z').to_a + ('0'..'9').to_a
+      SIZE = ALPHABET.length
+
+      # Returns random strings of <b> equal length </b>.
+      # The length of each string is determined by the parameter passed.
+      # The characters that can appear in returned strings are defined by
+      # the {#ALPHABET}.
+      # @param howmany [Integer] How many random strings do you need?
+      # @param rest [Integer] Optional arguments. First argument should be the length of
+      # each string in returned set. If unspecified, this is calculated from first
+      # argument, howmany, such that the length is enough to generate strings from the
+      # entire ALPHABET.
+      def self.ascii_strings(howmany, *rest)
+        p howmany, rest if $DEBUG
+        raise ArgumentError, "Size must be positive integer" if howmany < 1
+        srand(Time.now.to_i)
+        strings = []
+        of_length = rest[0] ? rest[0] : get_string_length_for(howmany)
+        1.upto howmany do
+          strings << get_ascii_string(of_length)
+        end
+        strings
+      end
+
+      private
+
+      def self.get_ascii_string(length)
+        i = 0
+        str = ""
+        while i < length
+          str << ALPHABET[rand(SIZE)]
+          i += 1
+        end
+        str
+      end
+
+      def self.get_string_length_for(size)
+        length = 0
+        while size > 0
+          length += 1
+          size /= SIZE
+        end
+        length
+      end
+    end
+  end
+end
+# Example:
+#DataSets = LilUtils::AlgoTestUtils::DataSets
+#puts DataSets.ascii_strings(10).sort
+#puts DataSets.ascii_strings(100, 10).sort

data/lib/lilutils/algo_test_utils_entry.rb

@@ -0,0 +1,4 @@
+# used to include code from all of the algo_test_utils classes
+# Add a line here when you add a new class that should be available to clients. Then, clients can just
+# require this one file.
+require 'lilutils/algo_test_utils/data_sets'

data/lib/lilutils/cli/cli.rb

@@ -0,0 +1,226 @@
+# Adds the simple_name method to Module.
+# @note A simple_name is just the name of the class/module without encompassing modules
+class Module
+  # suggested by Brian Candler
+  def simple_name
+    name.gsub(/^.*::/, '')
+  end
+end
+
+# The main module, wrapped inside LilUtils
+# Provides functionality to interact with users on a <i> command line </i>
+module LilUtils
+
+  module CLI
+
+    # Models an arbitrary option that user has choice to choose. Every Option has a name and a key.
+    # The name of an Option is its given name capitalized and its key is first character in its name in lower case. For example,
+    # for an option constructed with the string "separate",  the actual name is "Separate" and key is 's'.
+    # Provides behavior for such an Option as far as its display, equality, validity etc. is
+    # concerned.
+    class Option
+      attr_reader :name
+      # constructs this option with a name. The first character of this is regarded its key, e.g. "Yes" and 'y'.
+      # Unless an option has a proper name (e.g. "Mozart"), do not use the default value of the parameter
+      def initialize(name=self.class.simple_name)
+        @name = name.capitalize
+        @name.freeze
+      end
+
+      def ==(other)
+        (other.is_a? Option) && (@name == other.name)
+      end
+
+      def valid_response(r)
+        key == r
+      end
+
+      def as_default
+        "*#{@name} (#{key})*"
+      end
+
+      def as_non_default
+        "#{@name} (#{key})"
+      end
+
+      def to_s
+        @name
+      end
+
+      def key
+        @name[0].downcase
+      end
+    end
+
+    # Models an Option that is completely specified by a single letter, e.g. "Y"
+    class SingleLetterOption < Option
+      def as_default
+        key.upcase
+      end
+
+      def as_non_default
+        key
+      end
+    end
+    # The class that identifies a user "Yes". This class is an example of an option where the name of
+    # the option is derived from the name of the class itself. Handy extension.
+    class Yes < SingleLetterOption
+    end
+
+    # The class that identifies a user "No".
+    # @see Yes
+    class No < SingleLetterOption
+    end
+
+    # The class that identifies a user "Cancel".
+    class Cancel < SingleLetterOption
+    end
+
+    # An Option with a name and a positive number used to identify its selection. This is useful when two
+    # Options start with the same character (e.g. "Chai" and "Coffee")
+    class NumberedOption < Option
+      attr_reader :number
+
+      def initialize(number, name)
+        super(name)
+        @number = number
+      end
+
+      # redefine
+      def ==(other)
+        @name == other.name && @number == other.number
+      end
+
+      # redefine
+      def valid_response(r)
+        @number.to_s == r
+      end
+
+      # redefine
+      def as_default
+        "*#{@name} (#{@number})*"
+      end
+
+      # redefine
+      def as_non_default
+        "#{@name} (#{@number})"
+      end
+
+      def to_s
+        "#{@name}, #{number}"
+      end
+    end
+
+    # Singletons
+    YES    = Yes.new
+    NO     = No.new
+    CANCEL = Cancel.new
+    YN     = [YES, NO]
+    YNC    = YN + [CANCEL]
+
+    # Models a generic list of options that determines if a particular key results in valid response.
+    # Takes care of generic behavior (display, validity of user response, defaults) when a list of
+    # options is presented to the user.
+    class OptionList
+      DEFAULT_PROMPT = "Do you want to proceed?"
+
+      def initialize(options, default_option_index, prompt, strict, istream=$stdin, ostream=$stdout)
+        # check, list must be non-nil and must have at least two elements
+        @options        = options
+        @default_option = options[default_option_index]
+        @prompt         = prompt
+        @strict         = strict
+        @istream        = istream
+        @ostream        = ostream
+      end
+
+      def valid_response?(r)
+        @options.each do |option|
+          debug "#{option} == #{@default_option} ? : (#{option == @default_option})"
+          return option if (option == @default_option && r == "") || (option.valid_response(r))
+        end
+        nil
+      end
+
+      # subclasses may override, but don't have to
+      def display_string
+        long_str = ""
+        @options.each_with_index do |option, index|
+          if option == @default_option
+            long_str << option.as_default
+          else
+            long_str << option.as_non_default
+          end
+          long_str << "/" if index < (@options.size-1)
+        end
+        "#{@prompt} [#{long_str}] "
+      end
+
+      # the whole point is subclasses get this for free
+      def show
+        @ostream.print "#{display_string}"
+        response = @istream.gets.chomp!
+        chosen   = valid_response? response
+        if @strict
+          until chosen
+            @ostream.print "\nSorry, I don't understand #{response}, #{display_string}"
+            response = @istream.gets.chomp!
+            chosen   = valid_response? response
+          end
+        else
+          chosen = @default_option # when not strict, any key => default option
+        end
+        chosen
+      end
+
+      def debug(str)
+        puts "debug: #{str}" if $DEBUG
+      end
+    end
+    # A class that models the simple yes/no interaction with user on command line. Provides several ways to customize.
+    # @example:
+    # ...
+    # Do you want to proceed [Y/n]? y (Enter)
+    # A simple Enter or 'y' returns the YES object. Pressing n returns NO object. Pressing anything else returns a
+    # value that depends on the mode which can be <i>strict</i>. If the mode is strict, it keeps on asking the user till s/he
+    # presses the correct key. If the mode is not strict, any invalid key (other than y, n, or enter) results in whatever
+    # the default option is. Note that the default option is shown as upper case key.
+    # @see CLI#YES
+    # @see #NO
+    class YesNo < OptionList
+      # Creates a YesNo interaction.
+      # @param [Option] default_option the option that should be treated as default. Its default is #YES :-)
+      # @param [String] prompt prompt that should appear. Default is #DEFAULT_PROMPT
+      # @param [Boolean] strict decides if the interaction should demand exact response and loop till user behaves
+      # @param [IO] istream input stream to read user response from
+      # @param [IO] ostream output stream to display output to
+      def initialize(default_option=YES, prompt=DEFAULT_PROMPT, strict=true, istream=$stdin, ostream=$stdout)
+        super(YN, YN.index(default_option), prompt, strict, istream, ostream)
+      end
+
+    end
+
+    class YesNoCancel < OptionList
+      def initialize(default_option=YES, prompt=DEFAULT_PROMPT, strict=true, istream=$stdin, ostream=$stdout)
+        super(YNC, YNC.index(default_option), prompt, strict, istream, ostream)
+      end
+    end
+    # An OptionList where all the Options are NumberedOptions. You can't mix NumberedOptions with others.
+    class NumberedOptions < OptionList
+      # all the options must be NumberedOption instances
+      def initialize(options, default_option_index, prompt, strict, istream=$stdin, ostream=$stdout)
+        super
+      end
+    end
+  end
+end
+
+#CLI=LilUtils::CLI
+#puts CLI::YesNo.new.show
+#puts CLI::YesNo.new(LilUtils::CLI::NO).show
+#puts CLI::YesNoCancel.new.show
+#puts CLI::OptionList.new([CLI::Option.new("Mozart"), CLI::Option.new("Beethoven")], 1, "Pick your pick: ", true).show
+#one = CLI::NumberedOption.new(1, "Standard")
+#two = CLI::NumberedOption.new(2, "Expedite")
+#three = CLI::NumberedOption.new(3, "Special")
+#puts CLI::NumberedOptions.new([one, two, three], 0, "Select shipping method: ", true).show

data/lib/lilutils/cli_entry.rb

@@ -0,0 +1,4 @@
+# Used to include code from all of the cli classes.
+# Add a line here when you add a new class that should be available to clients. Then, clients can just
+# require this one file.
+require 'lilutils/cli/cli'

data/lib/lilutils/misc/misc.rb

@@ -0,0 +1,2 @@
+module Misc
+end

data/lib/lilutils/misc/pascal.rb

@@ -0,0 +1,21 @@
+module LilUtils
+  module Misc
+    module Pascal
+      # Returns the nth row of the Pascal's triangle as an array of n+1 elements.
+      # This is an O(n) algorithm. Uses: nCr = nCr-1*(n-r+1)/r which calculates
+      # @param [Integer] n starts at 1
+      # @return [Array] of Integers representing numbers in given row.
+      def self.row(n)
+        raise ArgumentError, "#{n} is not valid" if !n.is_a?(Integer) || n < 1
+        len = n == 1 ? 1 : n + 1
+        a = Array.new(len); a[0] = a[-1] = 1
+        1.upto n/2 do |r|
+          a[r] = a[-r-1] = a[r-1] * (n-r+1)/r
+          r += 1
+        end
+        a
+      end
+    end
+  end
+end
+#p LilUtils::Misc::Pascal.row(ARGV[0].to_i)

data/lib/lilutils/misc_entry.rb

@@ -0,0 +1,5 @@
+# used to include code from all of the misc classes
+# Add a line here when you add a new class that should be available to clients. Then, clients can just
+# require this one file.
+require 'lilutils/misc/misc'
+require 'lilutils/misc/pascal'

data/lib/lilutils.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'lilutils/cli_entry'
+require 'lilutils/misc_entry'
+require 'lilutils/algo_test_utils_entry'
+module Lilutils
+  VERSION = '0.0.1'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/lilutils.rb'}"
+puts "Loading lilutils gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/algo_test_utils/data_sets_test.rb

@@ -0,0 +1,12 @@
+require "test/unit"
+require "lilutils/algo_test_utils/data_sets"
+
+class DataSetsTest < Test::Unit::TestCase
+
+  DS = LilUtils::AlgoTestUtils::DataSets
+
+  def test_ascii_strings
+    strs = DS.ascii_strings(100, 5)
+    assert_equal(100, strs.size)
+  end
+end

data/test/cli/cli_basic_test.rb

@@ -0,0 +1,126 @@
+require "test/unit"
+require File.dirname(__FILE__) + '/../../lib/lilutils'
+require 'stringio'
+
+class BasicCLITest < Test::Unit::TestCase
+
+  CLI = LilUtils::CLI
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_yes_no
+    is  = StringIO.open("y\n", "r")
+    os  = StringIO.open("", "w")
+    yes = CLI::YesNo.new(CLI::YES, CLI::YesNo::DEFAULT_PROMPT, true, is, os)
+    assert_equal(CLI::YES, yes.show)
+
+    is = StringIO.open("\n", "r") # just enter a newline character
+    no = CLI::YesNo.new(CLI::NO, CLI::YesNo::DEFAULT_PROMPT, true, is, os)
+    assert_equal(CLI::NO, no.show)
+
+    is = StringIO.open("c\n", "r") # invalid character
+    no = CLI::YesNo.new(CLI::NO, CLI::YesNo::DEFAULT_PROMPT, false, is, os) # we must not be strict here
+    assert_equal(CLI::NO, no.show) # default should prevail as 'c' is not recognized
+
+    is = StringIO.open("go away\nz\n\n", "r") # 2 invalid attempts and then a valid attempt to select the default
+    no = CLI::YesNo.new(CLI::NO, CLI::YesNo::DEFAULT_PROMPT, false, is, os) # we must not be strict here
+    assert_equal(CLI::NO, no.show) # default should prevail as we encounter a mere newline
+    is.close
+    os.close
+  end
+
+  def test_yes_no_cancel
+    is = StringIO.open("", "r")
+    os = StringIO.open("", "w")
+    CLI::YNC.each do |option|
+      is  = StringIO.open("#{option.key}\n", "r")
+      ync = CLI::YesNoCancel.new(option, "test", true, is, os)
+      assert_equal(option, ync.show)
+    end
+    CLI::YNC.each do |option|
+      is  = StringIO.open("\n", "r") # default option matches a mere Enter
+      ync = CLI::YesNoCancel.new(option, "test", true, is, os)
+      assert_equal(option, ync.show)
+    end
+    is.close
+    os.close
+  end
+
+  def test_display_string
+    prompt  = "Pick one: "
+    options = []
+    options << CLI::SingleLetterOption.new("Coffee") << CLI::SingleLetterOption.new("Tea") << CLI::SingleLetterOption.new("Milk")
+    # make Tea the default
+    list     = CLI::OptionList.new(options, 1, prompt, true)
+    expected = prompt + " [c/T/m] "
+    assert_equal(expected, list.display_string)
+  end
+
+  def test_generic_1
+    os       = StringIO.open("", "w")
+    cat      = CLI::Option.new("cat")
+    dog      = CLI::Option.new("dog")
+    elephant = CLI::Option.new("elephant")
+    frog     = CLI::Option.new("frog")
+
+    is       = StringIO.open("z\ne\n", "r") # choose invalid option and then elephant
+    list = CLI::OptionList.new([cat, dog, elephant, frog], 3, "", true, is, os)  # make frog the default
+    assert_equal(elephant, list.show)
+
+    is.close
+    os.close
+  end
+  
+  def test_numbers_1
+    os       = StringIO.open("", "w")
+    latte    = CLI::NumberedOption.new(1, "Latte")
+    mocha    = CLI::NumberedOption.new(2, "Mocha")
+    chai     = CLI::NumberedOption.new(3, "Chai")
+    machiato = CLI::NumberedOption.new(4, "Caramel Machiato")
+    is       = StringIO.open("3\n", "r") # choose Chai
+    list     = CLI::NumberedOptions.new([latte, mocha, chai, machiato], 0, "Pick your favorite: ", true, is, os) # make latte the default
+    assert_equal(chai, list.show)
+    
+    is.close
+    os.close
+  end
+
+  def test_long_names
+    os = StringIO.open("", "w")
+
+    l = CLI::Option.new("Left Turn")
+    r = CLI::Option.new("Right Turn")
+    u = CLI::Option.new("U Turn")
+
+    is = StringIO.open("u\n", "r") # take a U turn
+    message = "What should I do?"
+    list = CLI::OptionList.new([l, r, u], 1, message, true, is, os)
+#    puts list.display_string
+    assert_equal(u, list.show)
+
+    is = StringIO.open("\n", "r") # right turn as default
+    list = CLI::OptionList.new([l, r, u], 1, message, true, is, os)
+    assert_equal(r, list.show) # enter = right
+
+    is = StringIO.open("r\n", "r") # right turn explicit
+    list = CLI::OptionList.new([l, r, u], 1, message, true, is, os)
+    assert_equal(r, list.show) # right turn selected
+
+    is = StringIO.open("e\nl\n", "r") # invalid and then left
+    list = CLI::OptionList.new([l, r, u], 1, message, true, is, os)
+    assert_equal(l, list.show) # left
+
+    expected_display_string = "#{message} [Left turn (l)/*Right turn (r)*/U turn (u)] "
+    assert_equal(expected_display_string, list.display_string)
+  end
+end

data/test/misc/misc_pascal_test.rb

@@ -0,0 +1,28 @@
+require "test/unit"
+require File.dirname(__FILE__) + '/../../lib/lilutils'
+require 'stringio'
+
+class PascalTest < Test::Unit::TestCase
+
+  PASCAL = LilUtils::Misc::Pascal
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_first_six
+    rows = {1 => [1], 2 => [1, 2, 1], 3 => [1, 3, 3, 1], 4 => [1, 4, 6, 4, 1],
+            5 => [1, 5, 10, 10, 5, 1], 6 => [1, 6, 15, 20, 15, 6, 1]}
+    rows.each_pair do |row_no, row |
+      assert_equal(row, PASCAL.row(row_no))
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require 'lilutils'

data/test/test_lilutils.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+require 'cli/cli_basic_test'
+require 'algo_test_utils/data_sets_test'
+require 'misc/misc_pascal_test'
+
+class TestLilutils < Test::Unit::TestCase
+
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: lilutils
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kedar Mhaswade
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-08 00:00:00 -08:00
+default_executable: cli-demo
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+description: Provides little utilties. It's a gem by a newbie, but I think it is quite useful. As of now, it provides a nicely abstracted out yes/no/cancel dialog box on a console.
+email: kedar.mhaswade@gmail.com
+executables: 
+- cli-demo
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- bin/cli-demo
+- lib/lilutils.rb
+- lib/lilutils/algo_test_utils/data_sets.rb
+- lib/lilutils/algo_test_utils_entry.rb
+- lib/lilutils/cli/cli.rb
+- lib/lilutils/cli_entry.rb
+- lib/lilutils/misc/misc.rb
+- lib/lilutils/misc/pascal.rb
+- lib/lilutils/misc_entry.rb
+- script/console
+- script/destroy
+- script/generate
+- test/algo_test_utils/data_sets_test.rb
+- test/cli/cli_basic_test.rb
+- test/misc/misc_pascal_test.rb
+- test/test_helper.rb
+- test/test_lilutils.rb
+has_rdoc: true
+homepage: http://github.com/kedarmhaswade/lilutils
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -896547783063548006
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Little utilities for everyone
+test_files: 
+- test/algo_test_utils/data_sets_test.rb
+- test/cli/cli_basic_test.rb
+- test/misc/misc_pascal_test.rb
+- test/test_helper.rb
+- test/test_lilutils.rb