linen 0.2.0

data/LICENSE

@@ -0,0 +1,2 @@
+Linen is copyright (c) 2007, LAIKA Inc.  Linen is proprietary software
+and is not available for use outside LAIKA.

data/README

@@ -0,0 +1,17 @@
+= Linen - Easy command line interfaces in Ruby
+
+Linen is a framework for creating applications that use a command line interface.  It features a simple plugin system, readline integration for history and completion, and other features.
+
+== Usage
+
+See USAGE[link:files/docs/USAGE.html].
+
+== Authors
+
+* Ben Bleything - <mailto:bbleything@laika.com>
+
+== License and Copyright
+
+Linen is copyright (c) 2007, LAIKA Inc.
+
+Portions of the code (notably the Rakefile) contain snippets from other projects.  These instances are documented in the header of the files involved.

data/Rakefile

@@ -0,0 +1,155 @@
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Based heavily on Ben Bleything's Rakefile for plist, which #
+# is in turn based on Geoffrey Grosenbach's Rakefile for     #
+# gruff.                                                     #
+#                                                            #
+# Includes whitespace-fixing task based on code from Typo.   #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+require 'fileutils'
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'linen'
+
+PKG_NAME      = 'linen'
+PKG_VERSION   = Linen::VERSION
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBYFORGE_PROJECT = "linen"
+RUBYFORGE_USER    = ENV['RUBYFORGE_USER']
+
+TEXT_FILES    = %w( Rakefile README LICENSE )
+TEST_FILES    = Dir.glob('test/test_*').delete_if { |item| item.include?( "\.svn" ) }
+LIB_FILES     = Dir.glob('lib/**/*').delete_if { |item| item.include?( "\.svn" ) }
+RELEASE_FILES = TEXT_FILES + LIB_FILES + TEST_FILES
+
+task :default => [ :test ]
+
+### Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+}
+
+
+desc "Clean pkg, coverage, and rdoc; remove .bak files"
+task :clean => [ :clobber_rdoc, :clobber_package, :clobber_coverage ] do
+  puts cmd = "find . -type f -name *.bak -delete"
+  `#{cmd}`
+end
+
+
+task :clobber_coverage do
+  puts cmd = "rm -rf coverage"
+  `#{cmd}`
+end
+
+
+desc "Generate coverage analysis with rcov (requires rcov to be installed)"
+task :rcov => [ :clobber_coverage ] do
+  puts cmd = "rcov -Ilib --xrefs -T test/*.rb"
+  puts `#{cmd}`
+end
+
+
+desc "Strip trailing whitespace and fix newlines for all release files"
+task :fix_whitespace => [ :clean ] do
+  RELEASE_FILES.each do |filename|
+    next if File.directory? filename
+
+    File.open(filename) do |file|
+      newfile = ''
+      needs_love = false
+
+      file.readlines.each_with_index do |line, lineno|
+        if line =~ /[ \t]+$/
+          needs_love = true
+          puts "#{filename}: trailing whitespace on line #{lineno}"
+          line.gsub!(/[ \t]*$/, '')
+        end
+
+        if line.chomp == line
+          needs_love = true
+          puts "#{filename}: no newline on line #{lineno}"
+          line << "\n"
+        end
+
+        newfile << line
+      end
+
+      if needs_love
+        tempname = "#{filename}.new"
+
+        File.open(tempname, 'w').write(newfile)
+        File.chmod(File.stat(filename).mode, tempname)
+
+        FileUtils.ln filename, "#{filename}.bak"
+        FileUtils.ln tempname, filename, :force => true
+        File.unlink(tempname)
+      end
+    end
+  end
+end
+
+
+desc "Copy documentation to rubyforge"
+task :update_rdoc => [ :rdoc ] do
+  Rake::SshDirPublisher.new("#{RUBYFORGE_USER}@rubyforge.org", "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}", "rdoc").upload
+end
+
+
+### Genereate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "Linen - A pluggable command-line interface library"
+  rdoc.options << '-SNmREADME'
+
+  rdoc.rdoc_files.include TEXT_FILES
+  rdoc.rdoc_files.include LIB_FILES
+  rdoc.rdoc_files.include Dir.glob('docs/**').delete_if {|f| f.include? 'jamis' }
+}
+
+
+### Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.name    = PKG_NAME
+  s.version = PKG_VERSION
+
+  s.summary     = "Linen - A pluggable command-line interface library"
+  s.description = <<-EOD
+Linen is a library which can be used to build a command-line interface for any purpose.  It features a plugin architecture to specify new tasks, Readline support, history, and more.
+  EOD
+
+  s.authors  = "LAIKA, Inc."
+  s.homepage = "http://opensource.laika.com"
+
+  s.rubyforge_project = RUBYFORGE_PROJECT
+
+  s.has_rdoc = true
+
+  s.files      = RELEASE_FILES
+  s.test_files = TEST_FILES
+
+  s.autorequire = 'linen'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end

data/lib/indifferent_hash.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class IndifferentHash < Hash
+  def []( key )
+    candidate = self.fetch( key ) rescue false
+    return candidate if candidate
+
+    [ :to_s, :intern ].each do |modifier|
+      candidate = self.fetch( key.send(modifier) ) if key.respond_to? modifier rescue false
+      return candidate if candidate
+    end
+
+    return nil
+  end
+end

data/lib/linen.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+### External libraries
+require 'abbrev'
+require 'readline'
+
+
+### internal but non-linen libraries
+require 'indifferent_hash'
+require 'string_extensions'
+
+
+module Linen
+  VERSION = "0.2.0"
+  SVNRev  = %q$Rev: 56 $
+
+
+  def self::plugins
+    return Linen::PluginRegistry.instance
+  end
+
+
+  def self::start
+    Linen::CLI.start_loop
+  end
+end
+
+
+### Plugin Infrastructure
+require 'linen/plugin_registry'
+require 'linen/plugin'
+
+
+### Other Infrastructure
+require 'linen/cli'
+require 'linen/exceptions'
+require 'linen/workspace'

data/lib/linen/cli.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class Linen::CLI
+  class << self
+    attr_accessor :prompt
+  end
+
+  @prompt = "linen> "
+
+  def self::parse_command( input )
+    ### * nil means ctrl-d, so exit.
+    ### * if they said "quit" or "exit", do so
+    ### * Size == 0 means empty command, so just return.
+    ###
+    ### otherwise, add to history.
+    if input.nil?
+      ### blank line to make ctrl-d not make the error live on the existing line
+      puts ; cleanup and exit
+    elsif input.chomp.size == 0 # empty string
+      return
+    else
+      Readline::HISTORY.push( input )
+    end
+
+    plugin, command, *arguments = input.split
+
+    if ['quit', 'exit'].abbrev.include? plugin
+      cleanup and exit
+    elsif ['help', '?'].abbrev.include? plugin
+      # they entered "help <plugin> <command> or some subset there of, which means
+      # that we have the plugin in command and the command in the first element of args.
+      plugin  = command.dup     rescue nil
+      command = arguments.shift rescue nil
+
+      if plugin and command
+        plugin, command = canonicalize( "#{plugin} #{command}" ).split rescue nil
+
+        # if either plugin or command is nil, lookup will fail; bail
+        return unless plugin = Linen.plugins[ plugin ]
+        return unless command = plugin.commands[ command ]
+
+        puts command.help
+      elsif plugin
+        return unless plugin = Linen.plugins[ canonicalize( plugin ) ]
+        puts plugin.help
+      else
+        help
+      end
+    elsif plugin.nil? or command.nil?
+      puts "You must enter both a plugin name and a command."
+    else
+      plugin, command, *args = canonicalize( input ).split
+
+      execute_command plugin, command, args
+    end
+  end
+
+
+  def self::start_loop
+    loop do
+      begin
+        input = Readline.readline( @prompt )
+      rescue Interrupt
+        puts "\nPlease type 'quit' or 'exit' to quit."
+      else
+        parse_command input
+      end
+
+      puts # blank line to clean things up
+    end
+  end
+
+
+  #######
+  private
+  #######
+
+  def self::canonicalize( input )
+    begin
+      expansion = expand_command( input )
+    rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError, Linen::CLI::AmbiguousPluginError, Linen::CLI::AmbiguousCommandError => e
+      puts e
+    end
+
+    return expansion
+  end
+
+
+  def self::cleanup
+    puts "Exiting..."
+
+    Linen.plugins.each do |p|
+      p.cleanup
+    end
+  end
+
+
+  def self::execute_command( plugin, command, args )
+    plugin = Linen.plugins[ plugin ]
+    command = plugin.commands[ command ]
+
+    workspace = Linen::Workspace.new
+
+    command.arguments.each do |arg_name|
+      argument = plugin.arguments[ arg_name ]
+
+      arg_value = args.shift
+
+      begin
+        if arg_value.nil?
+          old_completion_proc = Readline.completion_proc
+          Readline.completion_proc = Proc.new {}
+
+          arg_value = Readline.readline( argument.prompt )
+
+          Readline.completion_proc = old_completion_proc
+        end
+
+        argument.validate arg_value
+
+      rescue Linen::Plugin::ArgumentError => e
+        print e
+
+        # reset arg_value to nil so we get prompted on retry
+        arg_value = nil
+
+        retry
+      else
+        arg_value = argument.convert( arg_value )
+        workspace.set_value arg_name, arg_value
+      end
+    end
+
+    puts command.execute( workspace )
+  end
+
+
+  def self::help
+    puts <<-END
+Usage: <plugin> <command> [<argument>, <argument>...]
+
+You may shorten the plugin and commands as long as the abbreviation
+is non-ambiguous.  For example, given two plugins 'addition' and
+'administration', you would need to supply at least three characters.
+
+Available plugins and commands:
+
+    END
+
+    Linen.plugins.each do |plugin|
+      puts "- #{plugin.short_name}"
+
+      plugin.commands.each do |name, command|
+        puts "  - #{name}"
+      end
+    end
+
+    puts <<-END
+
+To get help with a plugin, enter "help <plugin>".  You may also enter
+"help <plugin> <command>" for help on a specific command.
+    END
+  end
+
+
+  ### First, try to complete the plugin name.  If we can't,
+  ### raise an exception saying so.
+  ###
+  ### Second, try to complete the command name.  If we can't,
+  ### raise an exception saying so.
+  ###
+  ### The caller is now responsible for flow control.
+  def self::expand_command( str )
+    plugin_candidates = Linen.plugins.collect {|p| p.short_name}.sort
+
+    ### empty string means we're trying to complete the plugin with nothing to go on
+    raise Linen::CLI::AmbiguousPluginError.new( plugin_candidates ) if str.empty?
+
+    plugin, command, *arguments = str.split
+
+    ### attempt to complete the plugin, raising an exception if it failes
+    completed_plugin = plugin_candidates.abbrev[ plugin ]
+
+    unless completed_plugin
+      refined_candidates = plugin_candidates.select {|p| p =~ /^#{plugin}/}
+
+      raise Linen::CLI::PluginNotFoundError, "Plugin '#{plugin}' not found." if refined_candidates.empty?
+      raise Linen::CLI::AmbiguousPluginError.new( refined_candidates, plugin )
+    end
+
+    ### if there's no command entered and no space after the plugin,
+    ### just return the plugin
+    return completed_plugin if command.nil? and str !~ /\s$/
+
+    ### If we've gotten here, we've now got the plugin in completed_plugin,
+    ### so attempt to complete the command
+    command_candidates = Linen.plugins[ completed_plugin ].commands.keys.map {|k| k.to_s}.sort
+
+    completed_command = command_candidates.abbrev[ command ]
+
+    unless completed_command
+      refined_candidates = command_candidates.select {|c| c =~ /^#{command}/}
+
+      raise Linen::CLI::CommandNotFoundError, "Command '#{command}' not found." if refined_candidates.empty?
+      raise Linen::CLI::AmbiguousCommandError.new( refined_candidates, command ), "The command you entered ('#{command}') is ambiguous; please select from the following:"
+    end
+
+    ### if we've gotten here, we're golden.  Everything is completed.  Rejoice!
+    output =  completed_plugin
+    output << " " + completed_command if completed_command
+    output << " " + arguments.join(' ') unless arguments.empty?
+
+    return output
+  end
+
+  Readline.basic_word_break_characters = ""
+
+  Readline.completion_proc = proc do |str|
+    begin
+      output = expand_command( str )
+    rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError => e
+      output = ''
+    rescue Linen::CLI::AmbiguousPluginError => e
+      output = e.candidates
+    rescue Linen::CLI::AmbiguousCommandError => e
+      output = e.candidates.map {|c| "#{str.split.first} #{c}"}
+    ensure
+      return output
+    end
+  end
+end
+
+Signal.trap( 'INT' ) { raise Interrupt }

data/lib/linen/exceptions.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class Linen::Plugin::ArgumentError < ArgumentError ; end
+class Linen::Plugin::PluginError   < TypeError     ; end
+
+class Linen::CLI::PluginNotFoundError  < NameError ; end
+class Linen::CLI::CommandNotFoundError < NameError ; end
+
+class Linen::CLI::AbstractAmbiguityError < NameError
+  attr_accessor :candidates, :input
+
+  def initialize( candidates = [], input = '' )
+    @candidates = candidates
+    @input      = input
+  end
+
+  def to_s
+    type = self.class.to_s.match( /Ambiguous(.*?)Error/ )[1].downcase
+
+    return "The #{type} you entered ('#{@input}') was ambiguous; please select from the following: #{@candidates.join ', '}"
+  end
+end
+
+class Linen::CLI::AmbiguousPluginError  < Linen::CLI::AbstractAmbiguityError ; end
+
+class Linen::CLI::AmbiguousCommandError < Linen::CLI::AbstractAmbiguityError
+  def to_s
+    @candidates.map! {|c| [plugin, c].join ' '}
+
+    super
+  end
+end

data/lib/linen/plugin.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class Linen::Plugin
+  class << self
+    attr_reader :commands
+  end
+
+
+  def self::inherited( plugin )
+    Linen::PluginRegistry.instance.register plugin
+  end
+
+
+  def self::short_name
+    self.to_s.downcase.gsub /plugin$/, ''
+  end
+
+
+  def self::help
+    output = []
+
+    desc = description || "No help for #{short_name}"
+
+    output << desc
+    output << nil #blank line
+    output << "Available commands:"
+    output << nil #blank line
+
+    commands.each do |name, command|
+      output << "- #{name}"
+    end
+
+    output << nil #blank line
+    output << "For detailed help on a command, enter \"help #{short_name} <command>\"".wrap
+
+    return output.join( "\n" )
+  end
+
+
+  def self::argument( name, opts = {} )
+    @defined_arguments ||= IndifferentHash.new
+
+    if opts[:error_message].nil? and opts['error_message'].nil?
+      opts[ :error_message ] = "The value for #{name} is invalid."
+    end
+
+    @defined_arguments[ name ] = Argument.new( self, name, opts )
+  end
+
+
+  ### If args is empty, assume it was called like Plugin.arguments,
+  ### so return the hash.
+  def self::arguments( *args )
+    @defined_arguments ||= IndifferentHash.new
+    
+    return @defined_arguments if args.empty?
+
+    args.each do |arg|
+      argument arg
+    end
+  end
+
+
+  def self::command( name, &block )
+    @commands ||= IndifferentHash.new
+
+    @commands[ name ] = Command.new( self, name, &block )
+  end
+
+
+  ### multi-purpose method!
+  ###
+  ### if passed a block, set this plugin's cleanup proc to the block.
+  ### if called without a block, execute the proc.
+  ###
+  ### this is meant to allow plugins to clean up after themselves.
+  def self::cleanup( &block )
+    if block_given?
+      @cleanup_proc = block
+    else
+      # if we didn't define a proc, don't try to call it
+      @cleanup_proc.call if @cleanup_proc
+    end
+  end
+
+
+  ### define the plugin's description, or fetch it if nothing passed
+  def self::description( input = nil )
+    return @description unless input
+
+    @description = input
+  end
+end
+
+class Linen::Plugin::Argument
+  attr_reader :name, :prompt
+
+  def initialize( plugin, name, opts )
+    @plugin     = plugin
+    @name       = name
+    @prompt     = opts[:prompt]     || "Please enter the value for #{@name}"
+    @validation = opts[:validation] || /^\w+$/
+    @conversion = opts[:conversion] || nil
+  end
+
+
+  def convert( value )
+    return value unless @conversion
+    return @conversion.call( value )
+  end
+
+
+  def validate( value )
+    if @validation.is_a? Proc
+      result = @validation.call( value )
+    else
+      result = ( value =~ @validation )
+    end
+
+    raise Linen::Plugin::ArgumentError, "Value '#{value}' is invalid for #{self.name}.  " unless result
+  end
+end
+
+class Linen::Plugin::Command
+  attr_reader :name, :arguments
+
+  def initialize( plugin, name, &block )
+
+    @plugin    = plugin
+    @name      = name
+    @arguments = []
+    @help_text = "No help for #{plugin.short_name} #{name}"
+
+    self.instance_eval &block
+  end
+  
+  
+  def execute( workspace = Linen::Workspace.new )
+    return workspace.instance_eval( &@action_proc )
+  end
+
+
+  def help
+    output = []
+
+    output << @help_text.wrap
+    output << nil # blank line
+
+    # this map turns our list of args into a list like this:
+    # <arg1> <arg2> <arg3> <arg4>...
+    arg_list = arguments.map {|a| "<#{a.to_s}>"}.join( ' ' )
+
+    output << "Usage: #{@plugin.short_name} #{name} #{arg_list}"
+
+    return output.join( "\n" )
+  end
+
+
+  #######
+  private
+  #######
+
+  def required_arguments( *args )
+    args.each do |arg|
+      raise Linen::Plugin::ArgumentError,
+        "Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
+
+      @arguments << arg
+    end
+  end
+  alias required_argument required_arguments
+
+
+  def help_message( message )
+    @help_text = message
+  end
+
+
+  def action( &block )
+    @action_proc = block
+  end
+end

data/lib/linen/plugin_registry.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+require 'singleton'
+
+class Linen::PluginRegistry
+  include Singleton
+
+  include Enumerable
+  def each
+    ### yield the actual plugin object, which knows its own name
+    @plugins.each { |name, plugin| yield plugin }
+  end
+
+
+  def register_plugin( plugin )
+    raise Linen::Plugin::ArgumentError, "Attempted to register something that is not a Linen::Plugin" unless
+      plugin < Linen::Plugin
+
+    @plugins ||= {}
+    @plugins[ plugin.short_name ] = plugin
+  end
+  alias register register_plugin
+  alias <<       register_plugin
+
+
+  def size
+    return @plugins.size
+  end
+
+
+  def []( name )
+    return @plugins[ name ]
+  end
+
+
+  def commands
+    if @commands.nil?
+      ### create @commands.  Each new key will get an empty array as its default value.
+      @commands = IndifferentHash.new
+
+      ### populates @commands as a hash of arrays.  The hash key is the command name (.to_s) and the value
+      ### is an array containing each plugin class in which that command is defined.
+      @plugins.each do |name, plugin|
+        plugin.commands.each do |name, cmd|
+          @commands[ name ] ||= []
+          @commands[ name ] << plugin
+        end
+      end
+    end
+
+    return @commands
+  end
+
+
+  def find_command( name )
+    return @commands[ name ]
+  end
+end

data/lib/linen/workspace.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class Linen::Workspace
+  def set_value( name, value )
+    # add getter
+    (class << self ; self ; end).instance_eval {
+      attr_reader name.to_s.intern
+    }
+
+    # add ivar
+    instance_variable_set "@#{name}", value
+  end
+end

data/lib/string_extensions.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+class String
+  def wrap(line_width = 72)
+    self.gsub(/\n/, "\n\n").gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
+  end
+end
+

data/test/test_cli.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+require 'test/unit'
+require 'linen'
+
+class TestCLICommandCompletion < Test::Unit::TestCase
+
+  ################
+  # test plugins #
+  ################
+
+  class ::TestPlugin < Linen::Plugin
+    command :add do;end
+    command :administer do;end
+    command :somethingelse do;end
+  end
+
+
+  class ::TeaPlugin < Linen::Plugin
+    command :foo do;end
+  end
+
+
+  class ::OtherPlugin < Linen::Plugin
+    command :food do;end
+  end
+
+
+  #########
+  # tests #
+  #########
+
+  def test_plugin_completion
+    all_plugins = Linen.plugins.map {|p| p.short_name}.sort
+
+    assert_raises_plugin_ambiguity_error( all_plugins ) do
+      complete ''
+    end
+
+    assert_raises_plugin_ambiguity_error( all_plugins.select {|p| p =~ /^te/} ) do
+      complete 'te'
+    end
+
+    assert_nothing_raised do
+      ### strip'ing because completion returns it with a trailing space
+      assert_equal "test", complete( 'tes' ).strip
+    end
+  end
+
+
+  def test_command_completion
+    test_commands = Linen.plugins[ 'test' ].commands.keys.map {|k| k.to_s}.sort
+
+    assert_raises_command_ambiguity_error( test_commands ) do
+      complete 'tes '
+    end
+
+    assert_raises_command_ambiguity_error( test_commands ) do
+      complete 'test '
+    end
+
+    starts_with_ad = test_commands.select {|c| c =~ /^ad/}
+
+    assert_raises_command_ambiguity_error( starts_with_ad ) do
+      assert_equal "test ad", complete( 'test ad' )
+    end
+
+    assert_raises_command_ambiguity_error( starts_with_ad ) do
+      assert_equal "test ad", complete( 'tes ad' )
+    end
+
+    assert_nothing_raised do
+      ### strip'ing because completion returns it with a trailing space
+      assert_equal "test administer", complete( 'test adm' ).strip
+      assert_equal "test administer", complete( 'tes adm' ).strip
+    end
+  end
+
+
+  #######
+  private
+  #######
+  def complete( str )
+    return Linen::CLI.expand_command( str )
+  end
+
+  def assert_raises_ambiguity_error( exception, candidates, &block )
+    begin
+      block.call
+    rescue exception => e
+      assert_equal candidates, e.candidates
+    else
+      flunk 'no exception raised!'
+    end
+  end
+
+  def assert_raises_plugin_ambiguity_error( candidates, &block )
+    assert_raises_ambiguity_error Linen::CLI::AmbiguousPluginError, candidates, &block
+  end
+
+  def assert_raises_command_ambiguity_error( candidates, &block )
+    assert_raises_ambiguity_error Linen::CLI::AmbiguousCommandError, candidates, &block
+  end
+end

data/test/test_indifferent_hash.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+require 'test/unit'
+require 'indifferent_hash'
+
+class TestIndifferentHash < Test::Unit::TestCase
+  def setup
+    @rhash = {
+      :symbol  => 'regular symbol',
+      'string' => 'regular string'
+    }
+
+    @ihash = IndifferentHash.new
+    @ihash[ :symbol ]  = 'indifferent symbol'
+    @ihash[ 'string' ] = 'indifferent string'
+  end
+
+
+  def test_string_to_symbol_lookups
+    key = 'symbol'
+
+    assert_nil @rhash[ key ]
+    assert_equal 'indifferent symbol', @ihash[ key ]
+  end
+
+
+  def test_symbol_to_string_lookups
+    key = :string
+
+    assert_nil @rhash[ key ]
+    assert_equal 'indifferent string', @ihash[ key ]
+  end
+
+
+  def test_literal_key_priority
+    ihash = IndifferentHash.new
+
+    ihash[ :key  ] = "symbol"
+    ihash[ 'key' ] = "string"
+
+    assert_equal "symbol", ihash[ :key  ]
+    assert_equal "string", ihash[ 'key' ]
+  end
+end

data/test/test_plugins.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+##############################################################
+# Copyright 2007, LAIKA, Inc.                                #
+#                                                            #
+# Authors:                                                   #
+#  * Ben Bleything <bbleything@laika.com>                    #
+##############################################################
+
+require 'test/unit'
+require 'linen'
+
+### a little helper for later
+class String
+  def to_regex
+    return /#{self}/
+  end
+end
+
+
+class TestPlugins < Test::Unit::TestCase
+
+  ########################
+  # "constant" variables #
+  ########################
+
+  @description = "This is some descriptions"
+  @help_msg  = "This is some help messagesess"
+  class << self
+    attr_reader :description, :help_msg
+  end
+
+  ################
+  # test plugins #
+  ################
+
+  class ::HelpfulPlugin < Linen::Plugin
+    puts TestPlugins.description
+    description TestPlugins.description
+
+    command :test do
+      help_message TestPlugins.help_msg
+    end
+  end
+
+
+  class ::UnhelpfulPlugin < Linen::Plugin
+    command :test do;end
+  end
+
+  #########
+  # tests #
+  #########
+
+  def test_plugin_help
+    assert HelpfulPlugin.help =~ TestPlugins.description.to_regex
+    assert UnhelpfulPlugin.help =~ /No help for unhelpful/
+  end
+
+
+  def test_command_help
+    assert HelpfulPlugin.commands[ :test ].help =~ TestPlugins.help_msg.to_regex
+    assert UnhelpfulPlugin.commands[ :test ].help =~ /No help for unhelpful test/
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: linen
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2007-09-10 00:00:00 -07:00
+summary: Linen - A pluggable command-line interface library
+require_paths: 
+- lib
+email: 
+homepage: http://opensource.laika.com
+rubyforge_project: linen
+description: Linen is a library which can be used to build a command-line interface for any purpose.  It features a plugin architecture to specify new tasks, Readline support, history, and more.
+autorequire: linen
+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
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- LAIKA, Inc.
+files: 
+- Rakefile
+- README
+- LICENSE
+- lib/indifferent_hash.rb
+- lib/linen
+- lib/linen/cli.rb
+- lib/linen/exceptions.rb
+- lib/linen/plugin.rb
+- lib/linen/plugin_registry.rb
+- lib/linen/workspace.rb
+- lib/linen.rb
+- lib/string_extensions.rb
+- test/test_cli.rb
+- test/test_indifferent_hash.rb
+- test/test_plugins.rb
+test_files: 
+- test/test_cli.rb
+- test/test_indifferent_hash.rb
+- test/test_plugins.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+