crosscase 0.0.1

data/MANIFEST

@@ -0,0 +1,6 @@
+crosscase.rb
+install.rb
+test.rb
+utils.rb
+MANIFEST
+README

data/README

@@ -0,0 +1,64 @@
+
+= CrossCase
+
+A mixin for auto-generating under_barred aliases for camelCased methods, and
+vice-versa.
+
+See crosscase.rb for more details.
+
+
+== Authors
+
+* Michael Granger <ged@FaerieMUD.org>
+
+=== Thanks
+
+* The denizens of #ruby-lang on irc.freenode.net, especially dblack, oGMo, and
+  rubyhacker1 who all helped with name suggestions.
+
+
+== Requirements
+
+* Ruby >= 1.8.0
+
+
+== Installation
+
+  $ su
+  # ruby install.rb
+
+
+=== Documentation
+
+If you have Dave Thomas's RDoc system installed, you can generate your very own
+HTML documentation for this module like so:
+
+  $ rdoc crosscase.rb README
+
+
+== More Information
+
+You can find more information about this module, including any updates, at its
+project page:
+
+  http://www.deveiate.org/code/CrossCase.shtml
+
+
+== Legal
+
+Copyright � 2003 The FaerieMUD Consortium. All rights reserved.
+
+This module is free software. You may use, modify, and/or redistribute this
+software under the same terms as Ruby.
+
+THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.
+
+
+ $Id: README,v 1.1 2003/07/25 16:54:09 deveiant Exp $
+
+
+
+
+

data/crosscase.gemspec

@@ -0,0 +1,21 @@
+require 'date'
+Gem::Specification.new do |s|
+  s.name = %q{crosscase}
+  s.version = "0.0.1"
+  s.date = Date.today.to_s
+  s.summary = %q{A mixin for auto-generating under_barred aliases for camelCased methods, and vice-versa.}
+  s.description =<<DESCRIPTION
+A mixin for auto-generating under_barred aliases for camelCased methods, and vice-versa.
+DESCRIPTION
+  s.author = %q{Michael Granger}
+  s.email = %q{ged@FaerieMUD.org}
+  s.homepage = %q{http://www.deveiate.org/code/CrossCase.html}
+  s.files = Dir.glob('**/*') 
+  s.require_path = %q{.}
+  s.autorequire = %q{crosscase}
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.test_files = %w{test.rb}
+  s.required_ruby_version = Gem::Version::Requirement.new(">= 1.8.0")
+end

data/crosscase.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/ruby
+# 
+# CrossCase - a mixin for making methods look the way you like 'em. Or for
+# making them look the way other people like 'em. Or something.
+# 
+# == Synopsis
+# 
+#   class MyClass
+#		include CrossCase
+#
+#		def underbarred_method; ...; end
+#		def camelCasedMethod; ...; end
+#	end
+#
+#	obj = MyClass::new
+#	obj.underbarredMethod
+#	obj.camel_cased_method
+#
+#	# -or-
+#
+#	class MyClass
+#		def underbarred_method; ...; end
+#		def camelCasedMethod; ...; end
+#	end
+#
+#	MyClass.extend( CrossCase )
+#	obj = MyClass::new
+#	obj.underbarredMethod
+#	obj.camel_cased_method
+#
+# == Description
+#
+# This module, when mixed into a Class or another Module, will provide
+# under_barred aliases for class or instance methods with names which follow the
+# camelCased naming conventions, and vice-versa. E.g., in a class which mixes in
+# CrossCase, defining a method which is called +foo_bar+ will also create an
+# alias for that method called +fooBar+.
+#
+# I wrote this module because I prefer camelCased method names, but also wish to
+# respect the preferences of my fellow Rubyists for whom such practices are an
+# abomination. And I'm too lazy to type
+#   alias :twinkle_twinkle :twinkleTwinkle
+# for every method. It's all about laziness. Or perhaps I'm catering to my
+# hubris. Or both; I'll shut up now.
+# 
+# == Caveats
+#
+# This module uses the +method_added+ and +singleton_method_added+ hooks to
+# generate aliases for new methods. If either or both of these methods are
+# already defined, they will be preserved as aliases when the Class or Module is
+# extended. It's up to you to return the favor should you create your own hook
+# after this module is mixed in to your class.
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# === Thanks To
+#
+# * The denizens of irc://irc.freenode.net/#ruby-lang, and especially dblack,
+#   oGMo, and rubyhacker1 for name suggestions.
+#
+# == Copyright
+#
+# Copyright (c) 2003 The FaerieMUD Consortium. All rights reserved.
+# 
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby
+# 
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == Version
+#
+#  $Id: crosscase.rb,v 1.2 2003/07/25 17:00:24 deveiant Exp $
+# 
+
+
+### A mixin which causes aliases for methods with either under_barred or
+### camelCased naming conventions to be created in the opposing
+### convention. E.g., in a class which mixes in CrossCase, defining a method
+### which is called +foo_bar+ will also create an alias for that method called
+### +fooBar+.
+module CrossCase
+
+	### Versioning constants
+	Version = /([\d\.]+)/.match( %q{$Revision: 1.2 $} )[1]
+	Rcsid = %q$Id: crosscase.rb,v 1.2 2003/07/25 17:00:24 deveiant Exp $
+
+	### The inclusion callback -- uses the Ouroboros trick to extend including
+	### classes.
+	def self::included( mod )
+		mod.extend( self )
+	end
+
+
+	### Object-extension callback -- installs aliases for any currently-extant
+	### class or instance methods, and installs callbacks that will create
+	### aliases for any subsequently-defined methods. Raises an error if any
+	### object except a Class or Module is extended.
+	def self::extend_object( mod )
+		raise TypeError, "Expected a Module or a Class, got a " +
+			mod.class.name unless
+			mod.is_a?( Module )
+
+		self::transformClassMethods( mod )
+		self::transformInstanceMethods( mod )
+		self::installMethodHooks( mod )
+	end
+
+
+	### Install +method_added+ and +singleton_method_added+ hooks into the given
+	### Module +mod+ which auto-generate aliases for new methods.
+	def self::installMethodHooks( mod )
+		mod.module_eval {
+			class << self
+				if respond_to?( :singleton_method_added )
+					alias :__cc_sma :singleton_method_added
+				end
+				def singleton_method_added( id )
+					if aliasName = CrossCase::transform( id )
+						CrossCase::installClassAlias( self, id, aliasName )
+					end
+					if respond_to?( :__cc_sma )
+						__cc_sma( id )
+					else
+						super
+					end
+				end
+
+				if respond_to?( :method_added )
+					alias :__cc_ma :method_added
+				end					
+				def method_added( id )
+					if aliasName = CrossCase::transform( id )
+						CrossCase::installAlias( self, id, aliasName )
+					end
+					if respond_to?( :__cc_ma )
+						__cc_ma( id )
+					else
+						super
+					end
+				end
+			end
+		}
+	end
+
+
+	### Search for and install aliases for either underbarred or camelCased
+	### class methods for +mod+ (a Class or Module).
+	def self::transformClassMethods( mod )
+		self::findTargetMethods( mod.singleton_methods(false) ) {|meth, aliasName|
+			self::installClassAlias( mod, meth, aliasName )
+		}
+	end
+
+
+	### Install an alias +aliasName+ for the given class method +meth+ of the
+	### Class or Module +mod+.
+	def self::installClassAlias( mod, meth, aliasName )
+		unless mod.respond_to?( aliasName )
+			code = %{
+				class << self; alias_method( :#{aliasName}, :#{meth} ); end
+			}
+			mod.module_eval( code, __FILE__, __LINE__ )
+		end
+	end
+
+
+	### Search for and install aliases for either underbarred or camelCased
+	### instance methods for +mod+ (a Class or Module).
+	def self::transformInstanceMethods( mod )
+		self::findTargetMethods( mod.instance_methods(false) ) {|meth, aliasName|
+			self::installAlias( mod, meth, aliasName )
+		}
+	end
+
+
+	### Install an alias +aliasName+ for the given instance method +meth+ of the
+	### Class or Module +mod+.
+	def self::installAlias( mod, meth, aliasName )
+		unless mod.instance_methods(true).include?( aliasName )
+			mod.module_eval %{alias_method :#{aliasName}, :#{meth}}
+		end
+	end	
+
+
+	### Find methods in the given +methodList+ which are candidates for
+	### aliasing.
+	def self::findTargetMethods( *methodList )
+		methodList.flatten.each {|meth|
+			next if /(singleton_)?method_added/ =~ meth
+			transformedName = transform( meth ) or next
+			yield( meth, transformedName )
+		}
+	end
+
+
+	### Return an alternate name for the given method id +mid+. If the method id
+	### is an under_barred method, returns a camelCased version, and
+	### vice-versa. If no alternate is called for, returns +nil+.
+	def self::transform( mid )
+		methodName = mid.to_s
+		transformedName = ''
+	
+		# camelCased methods
+		if /[A-Z]/.match( methodName ) && !/_/.match( methodName )
+			transformedName = methodName.gsub( /([a-z0-9])([A-Z])/ ) {|match|
+				$1 + '_' + $2
+			}.downcase
+			
+		# underbarred_methods
+		elsif !/A-Z/.match( methodName ) && /[a-z0-9]_[a-z]/.match( methodName )
+			transformedName = methodName.gsub( /([a-z0-9])_([a-z])/ ) {|match|
+				$1 + $2.upcase
+			}
+
+		else
+			transformedName = nil
+		end
+		
+		return transformedName
+	end
+
+
+end
+
+
+if $0 == __FILE__
+	require './utils'
+	include UtilityFunctions
+	$yaml = false
+
+	class Foo #:nodoc:
+		def self::singleton_method_added( id )
+			$stderr.puts "Original sma: Added #{id} to #{self.inspect}"
+		end
+
+		def self::method_added( id )
+			$stderr.puts "Original ma: Added #{id} to #{self.inspect}"
+		end
+
+		def self::classPreCamelMethod
+			"classPreCamelMethod"
+		end
+
+		def self::class_pre_underbarred_method
+			"class_pre_underbarred_method"
+		end
+
+		def preCamelCasedMethod
+			"preCamelCasedMethod"
+		end
+
+		def pre_underbarred_method
+			"pre_underbarred_method"
+		end
+
+		extend CrossCase
+
+		def self::classCamelMethod
+			"classCamelMethod"
+		end
+
+		def self::class_underbarred_method
+			"class_underbarred_method"
+		end
+
+		def camelCasedMethod
+			"camelCasedMethod"
+		end
+
+		def underbarred_method
+			"underbarred_method"
+		end
+	end
+
+	f = nil
+	try( "to instantiate Foo" ) { f = Foo::new }
+	%w{classPreCamelMethod class_pre_camel_method
+		class_pre_underbarred_method classPreUnderbarredMethod
+		classCamelMethod class_camel_method
+		class_underbarred_method classUnderbarredMethod
+		}.
+		sort.each {|meth|
+		try( "to call #{meth} on Foo" ) {
+			Foo.send( meth )
+		}
+	}
+	Foo.instance_methods(false).sort.each {|meth|
+		try( "to call #{meth} on the instance of Foo" ) {
+			f.send( meth )
+		}
+	}
+end
+

data/install.rb

@@ -0,0 +1,85 @@
+# install.rb
+#
+# $Date: 2003/07/25 15:43:29 $
+# Copyright (c) 2000 Masatoshi SEKI
+#
+# install.rb is copyrighted free software by Masatoshi SEKI.
+# You can redistribute it and/or modify it under the same term as Ruby.
+
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+class Installer
+  protected
+  def install(from, to, mode = nil, verbose = false)
+    str = "install '#{from}' to '#{to}'"
+    str += ", mode=#{mode}" if mode
+    puts str if verbose
+  end
+
+  protected
+  def makedirs(*dirs)
+    for d in dirs
+      puts "mkdir #{d}"
+    end
+  end
+
+  def initialize(test=false)
+    @version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+    @libdir = File.join(CONFIG["libdir"], "ruby", @version)
+    @sitelib = find_site_libdir
+    @ftools = (test) ? self : File
+  end
+  public
+  attr_reader(:libdir, :sitelib)
+
+  private
+  def find_site_libdir
+    site_libdir = $:.find {|x| x =~ /site_ruby$/}
+    if !site_libdir
+      site_libdir = File.join(@libdir, "site_ruby")
+    elsif site_libdir !~ Regexp::new( Regexp.quote(@version) )
+      site_libdir = File.join(site_libdir, @version)
+    end
+    site_libdir
+  end
+
+  public
+  def files_in_dir(dir)
+    list = []
+    Find.find(dir) do |f|
+      list.push(f)
+    end
+    list
+  end
+
+  public
+  def install_files(srcdir, files, destdir=@sitelib)
+    path = []
+    dir = []
+
+    for f in files
+      next if (f = f[srcdir.length+1..-1]) == nil
+      path.push f if File.ftype(File.join(srcdir, f)) == 'file'
+      dir |= [ File.dirname(File.join(destdir, f)) ]
+    end
+    @ftools.makedirs(*dir)
+    for f in path
+      @ftools.install(File.join(srcdir, f), File.join(destdir, f), nil, true)
+    end
+  end
+
+  public
+  def install_rb
+    intall_files('lib', files_in_dir('lib'))
+  end
+end
+
+if __FILE__ == $0
+  inst = Installer.new(ARGV.shift == '-n')
+  inst.install_files('.', ['./crosscase.rb'])
+end
+

data/test.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/ruby
+# = test.rb
+#
+#	Test suite for CrossCase
+#
+# == Author
+# 
+# Michael Granger <ged@FaerieMUD.org>
+# 
+# Copyright (c) 2003 The FaerieMUD Consortium. All rights reserved.
+# 
+# This program is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby itself.
+# 
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == Version
+#
+#  $Id: test.rb,v 1.1.1.1 2003/07/25 15:43:29 deveiant Exp $
+# 
+#
+
+$:.unshift "."
+
+require 'test/unit'
+require 'crosscase'
+
+$stderr.sync = $stdout.sync = true
+
+### Reactor test case
+class CrossCaseTestCase < Test::Unit::TestCase
+
+	# Test to be sure the module loaded
+	def test_00_module
+		assert_instance_of Module, CrossCase, "CrossCase module didn't load"
+	end
+
+	# Test pre-include
+	def test_10_preinclude
+		rval = obj = testClass = nil
+		
+		assert_nothing_raised {
+			testClass = Class::new( Object ) {
+				include CrossCase
+				def underbarred_method; "under_barred"; end
+				def camelCasedMethod; "camelCased"; end
+			}
+		}
+
+		obj = testClass::new
+		assert_respond_to obj, :underbarredMethod,
+			"alias for underbarred_method"
+		assert_respond_to obj, :camel_cased_method,
+			"alias for camelCasedMethod"
+	end
+
+end # class CrossCaseTestCase
+
+
+
+
+
+
+
+

data/utils.rb

@@ -0,0 +1,400 @@
+#
+#	Install/distribution utility functions
+#	$Id: utils.rb,v 1.1.1.1 2003/07/25 15:43:29 deveiant Exp $
+#
+#	Copyright (c) 2001-2003, The FaerieMUD Consortium.
+#
+#	This is free software. You may use, modify, and/or redistribute this
+#	software under the terms of the Perl Artistic License. (See
+#	http://language.perl.com/misc/Artistic.html)
+#
+
+
+BEGIN {
+	begin
+		require 'readline'
+		include Readline
+	rescue LoadError => e
+		$stderr.puts "Faking readline..."
+		def readline( prompt )
+			$stderr.print prompt.chomp
+			return $stdin.gets.chomp
+		end
+	end
+
+	begin
+		require 'yaml'
+		$yaml = true
+	rescue LoadError => e
+		$stderr.puts "No YAML; try() will use .inspect instead."
+		$yaml = false
+	end
+}
+
+module UtilityFunctions
+
+	# The list of regexen that eliminate files from the MANIFEST
+	ANTIMANIFEST = [
+		/makedist\.rb/,
+		/\bCVS\b/,
+		/~$/,
+		/^#/,
+		%r{docs/html},
+		%r{docs/man},
+		/^TEMPLATE/,
+		/\.cvsignore/,
+		/\.s?o$/
+	]
+
+	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
+	AnsiAttributes = {
+		'clear'      => 0,
+		'reset'      => 0,
+		'bold'       => 1,
+		'dark'       => 2,
+		'underline'  => 4,
+		'underscore' => 4,
+		'blink'      => 5,
+		'reverse'    => 7,
+		'concealed'  => 8,
+
+		'black'      => 30,   'on_black'   => 40, 
+		'red'        => 31,   'on_red'     => 41, 
+		'green'      => 32,   'on_green'   => 42, 
+		'yellow'     => 33,   'on_yellow'  => 43, 
+		'blue'       => 34,   'on_blue'    => 44, 
+		'magenta'    => 35,   'on_magenta' => 45, 
+		'cyan'       => 36,   'on_cyan'    => 46, 
+		'white'      => 37,   'on_white'   => 47
+	}
+
+	ErasePreviousLine = "\033[A\033[K"
+
+
+	###############
+	module_function
+	###############
+
+	# Create a string that contains the ANSI codes specified and return it
+	def ansiCode( *attributes )
+		return '' unless /(?:vt10[03]|xterm(?:-color)?|linux)/i =~ ENV['TERM']
+		attr = attributes.collect {|a| AnsiAttributes[a] ? AnsiAttributes[a] : nil}.compact.join(';')
+		if attr.empty? 
+			return ''
+		else
+			return "\e[%sm" % attr
+		end
+	end
+
+	# Test for the presence of the specified <tt>library</tt>, and output a
+	# message describing the test using <tt>nicename</tt>. If <tt>nicename</tt>
+	# is <tt>nil</tt>, the value in <tt>library</tt> is used to build a default.
+	def testForLibrary( library, nicename=nil )
+		nicename ||= library
+		message( "Testing for the #{nicename} library..." )
+		if $:.detect {|dir| File.exists?(File.join(dir,"#{library}.rb")) || File.exists?(File.join(dir,"#{library}.so"))}
+			message( "found.\n" )
+			return true
+		else
+			message( "not found.\n" )
+			return false
+		end
+	end
+
+	# Test for the presence of the specified <tt>library</tt>, and output a
+	# message describing the problem using <tt>nicename</tt>. If
+	# <tt>nicename</tt> is <tt>nil</tt>, the value in <tt>library</tt> is used
+	# to build a default. If <tt>raaUrl</tt> and/or <tt>downloadUrl</tt> are
+	# specified, they are also use to build a message describing how to find the
+	# required library. If <tt>fatal</tt> is <tt>true</tt>, a missing library
+	# will cause the program to abort.
+	def testForRequiredLibrary( library, nicename=nil, raaUrl=nil, downloadUrl=nil, fatal=true )
+		nicename ||= library
+		unless testForLibrary( library, nicename )
+			msgs = [ "You are missing the required #{nicename} library.\n" ]
+			msgs << "RAA: #{raaUrl}\n" if raaUrl
+			msgs << "Download: #{downloadUrl}\n" if downloadUrl
+			if fatal
+				abort msgs.join('')
+			else
+				errorMessage msgs.join('')
+			end
+		end
+		return true
+	end
+
+	### Output <tt>msg</tt> as a ANSI-colored program/section header (white on
+	### blue).
+	def header( msg )
+		msg.chomp!
+		$stderr.puts ansiCode( 'bold', 'white', 'on_blue' ) + msg + ansiCode( 'reset' )
+		$stderr.flush
+	end
+
+	### Output <tt>msg</tt> to STDERR and flush it.
+	def message( msg )
+		$stderr.print ansiCode( 'cyan' ) + msg + ansiCode( 'reset' )
+		$stderr.flush
+	end
+
+	### Output the specified <tt>msg</tt> as an ANSI-colored error message
+	### (white on red).
+	def errorMessage( msg )
+		message ansiCode( 'bold', 'white', 'on_red' ) + msg + ansiCode( 'reset' )
+	end
+
+	### Output the specified <tt>msg</tt> as an ANSI-colored debugging message
+	### (yellow on blue).
+	def debugMsg( msg )
+		return unless $DEBUG
+		msg.chomp!
+		$stderr.puts ansiCode( 'bold', 'yellow', 'on_blue' ) + ">>> #{msg}" + ansiCode( 'reset' )
+		$stderr.flush
+	end
+
+	### Erase the previous line (if supported by your terminal) and output the
+	### specified <tt>msg</tt> instead.
+	def replaceMessage( msg )
+		print ErasePreviousLine
+		message( msg )
+	end
+
+	### Output a divider made up of <tt>length</tt> hyphen characters.
+	def divider( length=75 )
+		puts "\r" + ("-" * length )
+	end
+	alias :writeLine :divider
+
+	### Output the specified <tt>msg</tt> colored in ANSI red and exit with a
+	### status of 1.
+	def abort( msg )
+		print ansiCode( 'bold', 'red' ) + "Aborted: " + msg.chomp + ansiCode( 'reset' ) + "\n\n"
+		Kernel.exit!( 1 )
+	end
+
+	### Output the specified <tt>promptString</tt> as a prompt (in green) and
+	### return the user's input with leading and trailing spaces removed.
+	def prompt( promptString )
+		promptString.chomp!
+		return readline( ansiCode('bold', 'green') + "#{promptString}: " + ansiCode('reset') ).strip
+	end
+
+	### Prompt the user with the given <tt>promptString</tt> via #prompt,
+	### substituting the given <tt>default</tt> if the user doesn't input
+	### anything.
+	def promptWithDefault( promptString, default )
+		response = prompt( "%s [%s]" % [ promptString, default ] )
+		if response.empty?
+			return default
+		else
+			return response
+		end
+	end
+
+	### Search for the program specified by the given <tt>progname</tt> in the
+	### user's <tt>PATH</tt>, and return the full path to it, or <tt>nil</tt> if
+	### no such program is in the path.
+	def findProgram( progname )
+		ENV['PATH'].split(File::PATH_SEPARATOR).each {|d|
+			file = File.join( d, progname )
+			return file if File.executable?( file )
+		}
+		return nil
+	end
+
+	### Using the CVS log for the given <tt>file</tt> attempt to guess what the
+	### next release version might be. This only works if releases are tagged
+	### with tags like 'RELEASE_x_y'.
+	def extractNextVersionFromTags( file )
+		message "Attempting to extract next release version from CVS tags for #{file}...\n"
+		raise RuntimeError, "No such file '#{file}'" unless File.exists?( file )
+		cvsPath = findProgram( 'cvs' ) or
+			raise RuntimeError, "Cannot find the 'cvs' program. Aborting."
+
+		output = %x{#{cvsPath} log #{file}}
+		release = [ 0, 0 ]
+		output.scan( /RELEASE_(\d+)_(\d+)/ ) {|match|
+			if $1.to_i > release[0] || $2.to_i > release[1]
+				release = [ $1.to_i, $2.to_i ]
+				replaceMessage( "Found %d.%02d...\n" % release )
+			end
+		}
+
+		if release[1] >= 99
+			release[0] += 1
+			release[1] = 1
+		else
+			release[1] += 1
+		end
+
+		return "%d.%02d" % release
+	end
+
+	### Extract the project name (CVS Repository name) for the given directory.
+	def extractProjectName
+		File.open( "CVS/Repository", "r").readline.chomp
+	end
+
+	### Read the specified <tt>manifestFile</tt>, which is a text file
+	### describing which files to package up for a distribution. The manifest
+	### should consist of one or more lines, each containing one filename or
+	### shell glob pattern.
+	def readManifest( manifestFile="MANIFEST" )
+		message "Building manifest..."
+		raise "Missing #{manifestFile}, please remake it" unless File.exists? manifestFile
+
+		manifest = IO::readlines( manifestFile ).collect {|line|
+			line.chomp
+		}.select {|line|
+			line !~ /^(\s*(#.*)?)?$/
+		}
+
+		filelist = []
+		for pat in manifest
+			$stderr.puts "Adding files that match '#{pat}' to the file list" if $VERBOSE
+			filelist |= Dir.glob( pat ).find_all {|f| FileTest.file?(f)}
+		end
+
+		message "found #{filelist.length} files.\n"
+		return filelist
+	end
+
+	### Given a <tt>filelist</tt> like that returned by #readManifest, remove
+	### the entries therein which match the Regexp objects in the given
+	### <tt>antimanifest</tt> and return the resultant Array.
+	def vetManifest( filelist, antimanifest=ANITMANIFEST )
+		origLength = filelist.length
+		message "Vetting manifest..."
+
+		for regex in antimanifest
+			if $VERBOSE
+				message "\n\tPattern /#{regex.source}/ removed: " +
+					filelist.find_all {|file| regex.match(file)}.join(', ')
+			end
+			filelist.delete_if {|file| regex.match(file)}
+		end
+
+		message "removed #{origLength - filelist.length} files from the list.\n"
+		return filelist
+	end
+
+	### Combine a call to #readManifest with one to #vetManifest.
+	def getVettedManifest( manifestFile="MANIFEST", antimanifest=ANTIMANIFEST )
+		vetManifest( readManifest(manifestFile), antimanifest )
+	end
+
+	### Given a documentation <tt>catalogFile</tt>, which is in the same format
+	### as that described by #readManifest, read and expand it, and then return
+	### a list of those files which appear to have RDoc documentation in
+	### them. If <tt>catalogFile</tt> is nil or does not exist, the MANIFEST
+	### file is used instead.
+	def findRdocableFiles( catalogFile="docs/CATALOG" )
+		startlist = []
+		if File.exists? catalogFile
+			message "Using CATALOG file (%s).\n" % catalogFile
+			startlist = getVettedManifest( catalogFile )
+		else
+			message "Using default MANIFEST\n"
+			startlist = getVettedManifest()
+		end
+
+		message "Looking for RDoc comments in:\n" if $VERBOSE
+		startlist.select {|fn|
+			message "  #{fn}: " if $VERBOSE
+			found = false
+			File::open( fn, "r" ) {|fh|
+				fh.each {|line|
+					if line =~ /^(\s*#)?\s*=/ || line =~ /:\w+:/ || line =~ %r{/\*}
+						found = true
+						break
+					end
+				}
+			}
+
+			message( (found ? "yes" : "no") + "\n" ) if $VERBOSE
+			found
+		}
+	end
+
+	### Open a file and filter each of its lines through the given block a
+	### <tt>line</tt> at a time. The return value of the block is used as the
+	### new line, or omitted if the block returns <tt>nil</tt> or
+	### <tt>false</tt>.
+	def editInPlace( file ) # :yields: line
+		raise "No block specified for editing operation" unless block_given?
+
+		tempName = "#{file}.#{$$}"
+		File::open( tempName, File::RDWR|File::CREAT, 0600 ) {|tempfile|
+			File::unlink( tempName )
+			File::open( file, File::RDONLY ) {|fh|
+				fh.each {|line|
+					newline = yield( line ) or next
+					tempfile.print( newline )
+				}
+			}
+
+			tempfile.seek(0)
+
+			File::open( file, File::TRUNC|File::WRONLY, 0644 ) {|newfile|
+				newfile.print( tempfile.read )
+			}
+		}
+	end
+
+	### Execute the specified shell <tt>command</tt>, read the results, and
+	### return them. Like a %x{} that returns an Array instead of a String.
+	def shellCommand( *command )
+		raise "Empty command" if command.empty?
+
+		cmdpipe = IO::popen( command.join(' '), 'r' )
+		return cmdpipe.readlines
+	end
+
+	### Execute a block with $VERBOSE set to +false+, restoring it to its
+	### previous value before returning.
+	def verboseOff
+		raise LocalJumpError, "No block given" unless block_given?
+
+		thrcrit = Thread.critical
+		oldverbose = $VERBOSE
+		begin
+			Thread.critical = true
+			$VERBOSE = false
+			yield
+		ensure
+			$VERBOSE = oldverbose
+			Thread.critical = false
+		end
+	end
+
+
+	### Try the specified code block, printing the given 
+	def try( msg, bind=nil )
+		result = nil
+		message "Trying #{msg}..."
+
+		begin
+			rval = nil
+			if block_given?
+				rval = yield
+			else
+				file, line = caller(1)[0].split(/:/,2)
+				rval = eval( msg, bind, file, line.to_i )
+			end
+
+			if $yaml
+				result = rval.to_yaml
+			else
+				result = rval.inspect
+			end
+		rescue Exception => err
+			nicetrace = err.backtrace.delete_if {|frame|
+				/in `(try|eval)'/ =~ frame
+			}.join("\n\t")
+			result = err.message + "\n\t" + nicetrace
+		ensure
+			puts result
+		end
+	end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: "0.8"
+specification_version: 1
+name: crosscase
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2004-10-27
+summary: "A mixin for auto-generating under_barred aliases for camelCased methods, and vice-versa."
+require_paths: 
+  - "."
+author: Michael Granger
+email: ged@FaerieMUD.org
+homepage: http://www.deveiate.org/code/CrossCase.html
+rubyforge_project: 
+description: "A mixin for auto-generating under_barred aliases for camelCased methods, and vice-versa."
+autorequire: crosscase
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+  version: 
+platform: ruby
+files: 
+  - README
+  - crosscase.rb
+  - install.rb
+  - test.rb
+  - MANIFEST
+  - utils.rb
+  - crosscase.gemspec
+test_files: 
+  - test.rb
+rdoc_options: 
+  - "--main"
+  - README
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: []
+requirements: []
+dependencies: []