tpkg 1.16.2

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/gempackagetask'
+spec = Gem::Specification.new do |s|
+  s.name	= 'tpkg'
+  s.summary	= 'tpkg Application Packaging & Deployment'
+  s.add_dependency('facter')
+  s.add_dependency('net-ssh')
+  s.version = '1.16.2'
+  s.authors = ['Darren Dao', 'Jason Heiss']
+  s.email = 'tpkg-users@lists.sourceforge.net'
+  s.homepage = 'http://tpkg.sourceforge.net'
+  s.rubyforge_project = 'tpkg'
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.8'
+  s.files	= Dir['**/**']
+  s.executables = [ 'tpkg', 'cpan2tpkg', 'gem2tpkg' ]
+end
+Rake::GemPackageTask.new(spec).define
+

data/bin/cpan2tpkg

@@ -0,0 +1,348 @@
+#!/home/t/bin/perl
+
+use warnings;
+use strict;
+
+use Getopt::Long;
+use CPAN;
+use Config;
+# According to the Changes file for EU::I this is the earliest version
+# that supports all of the ExtUtils::Installed->new() parameters we use.
+use ExtUtils::Installed 1.41_03;
+use File::Temp qw(tempdir);
+use File::Find;      # find
+use File::Path;      # mkpath
+use File::Basename;  # basename, dirname
+use File::Copy;      # copy
+use File::Spec;      # catdir, catfile, etc.
+use Storable qw(dclone);
+
+sub usage
+{
+	die <<EOF;
+Usage: cpan2tpkg
+    [--version version]
+       Version of module to install
+    [--package-version version]
+       Package version to use in tpkg, defaults to 1
+    [--extra-deps foo,1.0,1.9999,bar,4.5,4.5,blah,,,]
+       Extra dependencies to add to the package
+    [--native-deps foo,1.0,1.9999,bar,4.5,4.5,blah,,,]
+       Native dependencies to add to the package
+    [--help]
+       Show this message
+
+All options can be shortened to anything that's unique.
+EOF
+}
+
+# FIXME: we're not actually using $modver, we're just letting CPAN installed the latest available version
+my $modver;
+my $pkgver = 1;
+my %extradeps = ();
+my $extradepsopts = '';
+my %nativedeps = ();
+my $nativedepsopts = '';
+my $help;
+
+my $getopt = GetOptions(
+	'version=s' => \$modver,
+	'package-version=s' => \$pkgver,
+	'extra-deps=s' => \$extradepsopts,
+	'native-deps=s' => \$nativedepsopts,
+	'help' => \$help);
+
+my $module = shift @ARGV;
+
+usage() if (!$getopt);
+usage() if ($help);
+usage() if (!$module);
+
+my @extradepsopts = split(/,/, $extradepsopts);
+while (scalar @extradepsopts)
+{
+	my $dep = shift @extradepsopts;
+	# These are optional, shift will return undef if they aren't present
+	# and we'll handle that properly when creating tpkg.xml
+	my $depminver = shift @extradepsopts;
+	my $depmaxver = shift @extradepsopts;
+	$extradeps{$dep} = {};
+	$extradeps{$dep}{minimum_version} = $depminver;
+	$extradeps{$dep}{maximum_version} = $depmaxver;
+}
+my @nativedepsopts = split(/,/, $nativedepsopts);
+while (scalar @nativedepsopts)
+{
+	my $dep = shift @nativedepsopts;
+	# These are optional, shift will return undef if they aren't present
+	# and we'll handle that properly when creating tpkg.xml
+	my $depminver = shift @nativedepsopts;
+	my $depmaxver = shift @nativedepsopts;
+	$nativedeps{$dep} = {};
+	$nativedeps{$dep}{minimum_version} = $depminver;
+	$nativedeps{$dep}{maximum_version} = $depmaxver;
+}
+
+# FIXME, pause for confirmation?
+printf "Running under $^X, version %vd\n", $^V;
+# Getting the major and minor versions out of $^X looks like it should be
+# more straighforward according to the documentation, but the structure of
+# $^X is different between Perl 5.8 and 5.10 and despite a few hours of
+# trying I'm not smart enough to sort it out.
+# Example $] from perl 5.8.8:  5.008008
+my ($major, my $minorpatch) = split(/\./, $]);
+my ($minor, $patch) = unpack('A3A3', $minorpatch);
+# Force conversion to number so that 010 becomes 10, etc.
+my $majornum = $major + 0;
+my $minornum = $minor + 0;
+my $majorminor = "$majornum$minornum";
+my $majordotminor = "$majornum.$minornum";
+
+# FIXME: distribute MyConfig.pm?
+# MyConfig.pm needs all sorts of OS-specific stuff (paths to make, gzip,
+# etc.) so distributing it would be a pain.  For now we don't, and thus
+# force the user to do their own CPAN configuration.  In Perl 5.10
+# that's fairly painless.
+
+my $modobj = CPAN::Shell->expand('Module', $module);
+if (!$modobj)
+{
+	die "Unable to find $module or something went wrong\n";
+}
+
+# Set install location to temp directory
+# There are two installers that modules might use to install themselves
+# (ExtUtils::MakeMaker or Module::Build), so we have to set two different
+# options to cover both possiblities.
+my $workdir = tempdir(CLEANUP => 1);
+print "Working directory: $workdir\n";
+# http://perldoc.perl.org/ExtUtils/MakeMaker.html#DESTDIR
+CPAN::Shell->o('conf', 'makepl_arg', "DESTDIR=$workdir");
+# http://perldoc.perl.org/Module/Build.html#INSTALL-PATHS
+CPAN::Shell->o('conf', 'mbuildpl_arg', "--destdir=$workdir");
+
+# FIXME: desired?
+#CPAN::Shell->o('conf', 'prerequisites_policy', "ask");
+
+# Install the module
+$modobj->install;
+
+# It is not nearly as straightforward as one might wish to get
+# ExtUtils::Installed to inspect only a specified directory structure and not
+# include system library directories. EU::I wants to look at a couple of
+# system directories from $Config, any directories in the PERL5LIB environment
+# variable, and any extra directories you pass it. You can work around the
+# system directories from $Config by passing EU::I your own modified $Config
+# via the config_override parameter. You can also empty out $ENV[PERL5LIB].
+# And that just leaves it searching the extra directories you pass it via the
+# extra_libs parameter. To further complicate matters EU::I searches the
+# directories in @INC when asked for the version of an installed module, but
+# allows you to customize that via the inc_override parameter.
+my @incwork;
+foreach my $incdir (@INC)
+{
+	push(@incwork, File::Spec->catdir($workdir, $incdir));
+}
+@incwork = sort(@incwork);
+# Lie to ExtUtils::Installed about the two directories from %Config it
+# cares about so that it only searches our working directory and no
+# system directories.
+my %myconfig = %{dclone(\%Config)};
+$myconfig{archlibexp} = File::Spec->catdir($workdir, $Config{archlibexp});
+$myconfig{sitearchexp} = File::Spec->catdir($workdir, $Config{sitearchexp});
+# EU::I searches PERL5LIB as well, so clear that out
+$ENV{PERL5LIB} = '';
+my $extinst = ExtUtils::Installed->new(
+	config_override=>\%myconfig,
+	inc_override=>\@incwork,
+	extra_libs=>\@incwork);
+
+print "Installed modules to be packaged (except Perl):\n";
+print join(', ', $extinst->modules), "\n";
+
+# Inspect temp directory and package each installed module
+foreach my $name ($extinst->modules)
+{
+	next if ($name eq 'Perl');
+	print "Packaging $name\n";
+	my $dashname = $name;
+	$dashname =~ s/::/-/g;
+	my $ver = $extinst->version($name);
+	print "Module version is $ver\n";
+	my %deps = ();
+	my $mod = CPAN::Shell->expand('Module', $name);
+	# Looks like newer versions of CPAN.pm have a CPAN::Module::distribution()
+	# method.  What I'm using here is a little hacky but works, so I
+	# don't think it is worth forcing users to use a newer version.
+	my $dist = CPAN::Shell->expand('Distribution', $mod->{RO}{CPAN_FILE});
+	# The docs say you have to call make before prereq_pm is available
+	$dist->make;
+	# If there are any pre-reqs capture those
+	if ($dist->prereq_pm)
+	{
+		# Older versions return a basic {module name => min version} structure
+		# Newer versions seperate build-time dependencies (build_requires)
+		# from run-time dependencies (requires), each of which has the
+		# {name=>minver} format.
+		my %prereqs = %{$dist->prereq_pm};
+		if (exists $prereqs{requires})
+		{
+			# If we got back the newer format we want to pull out the run-time
+			# requirements. If there are no run-time requirements then
+			# $prereqs{requires} will be undef.
+			if ($prereqs{requires})
+			{
+				%prereqs = %{$prereqs{requires}};
+			}
+			else
+			{
+				%prereqs = ();
+			}
+		}
+		foreach my $dep (keys %prereqs)
+		{
+			# Skip dependencies on core modules
+			my $depmod = CPAN::Shell->expand('Module', $dep);
+			# This is a bit of an indirect way to identify core modules
+			# but the only way I can figure out.  Core stuff gets
+			# installed with perl into /home/t/perl-version, CPAN
+			# modules into /home/t/lib/perl5/site_perl.  The "d" in
+			# dslip_status has "s" as one of it's possible values,
+			# meaning "Standard, supplied with Perl 5" according to the
+			# docs.  However, that doesn't seem to be set reliably.
+			if ($depmod->inst_file =~ m,/home/t/perl,)
+			{
+				print "Prereq $dep is a core module, skipping\n";
+				next;
+			}
+			
+			my $dashdep = $dep;
+			$dashdep =~ s/::/-/g;
+			$deps{$dashdep} = {};
+			if ($prereqs{$dep} ne '0')
+			{
+				$deps{$dashdep}{minimum_version} = $prereqs{$dep};
+			}
+		}
+	}
+	my $tpkgdir = tempdir(CLEANUP =>1);
+	print "Packaging into $tpkgdir\n";
+	mkdir("$tpkgdir/root");
+	my $nativefile;
+	foreach my $packlistfile ($extinst->files($name))
+	{
+		chomp($packlistfile);
+		# Chop off $workdir
+		$packlistfile =~ s/^$workdir//;
+		# Make directory tree in $tpkgdir
+		mkpath("$tpkgdir/root/" . dirname($packlistfile));
+		# Copy file
+		copy("$workdir/$packlistfile", "$tpkgdir/root/$packlistfile");
+		if ($packlistfile =~ quotemeta($Config{archname}))
+		{
+			$nativefile = 1;
+		}
+	}
+	# Create tpkg.xml
+	open(my $xmlfh, '>', "$tpkgdir/tpkg.xml") or die;
+	print $xmlfh '<?xml version="1.0" encoding="UTF-8"?>', "\n";
+	print $xmlfh '<!DOCTYPE tpkg SYSTEM "http://tpkg.sourceforge.net/tpkg-1.0.dtd">', "\n";
+	print $xmlfh '<tpkg>', "\n";
+	print $xmlfh "  <name>cpan-perl$majorminor-$dashname</name>", "\n";
+	print $xmlfh "  <version>$ver</version>", "\n";
+	print $xmlfh "  <package_version>$pkgver</package_version>", "\n";
+	print $xmlfh '  <maintainer>cpan2tpkg</maintainer>', "\n";
+	# If the package has native code then it needs to be flagged as
+	# specific to the OS and architecture
+	if ($nativefile)
+	{
+		my $os;
+		my $arch;
+		open(my $tpkgqefh, '-|', 'tpkg --qe') or die;
+		while(my $tpkgqeline = <$tpkgqefh>)
+		{
+			chomp($tpkgqeline);
+			if ($tpkgqeline =~ /^Operating System: (.*)/)
+			{
+				$os = $1;
+			}
+			elsif ($tpkgqeline =~ /^Architecture: (.*)/)
+			{
+				$arch = $1;
+			}
+		}
+		close($tpkgqefh);
+		if (!$os || !$arch)
+		{
+			die "Unable to read OS and architecture from tpkg --qe";
+		}
+		# Packages built on Red Hat should work on CentOS and
+		# vice-versa
+		if ($os =~ /RedHat-(.*)/)
+		{
+			$os = $os . ",CentOS-$1";
+		}
+		elsif ($os =~ /CentOS-(.*)/)
+		{
+			$os = $os . ",RedHat-$1";
+		}
+		print $xmlfh "  <operatingsystem>$os</operatingsystem>", "\n";
+		print $xmlfh "  <architecture>$arch</architecture>", "\n";
+	}
+	# Insert appropriate dependencies into the package
+	print $xmlfh '  <dependencies>', "\n";
+	foreach my $dep (keys %deps)
+	{
+		print $xmlfh '    <dependency>', "\n";
+		print $xmlfh "      <name>cpan-perl$majorminor-$dep</name>", "\n";
+		if ($deps{$dep}{minimum_version})
+		{
+			print $xmlfh "      <minimum_version>$deps{$dep}{minimum_version}</minimum_version>", "\n";
+		}
+		if ($deps{$dep}{maximum_version})
+		{
+			print $xmlfh "      <maximum_version>$deps{$dep}{maximum_version}</maximum_version>", "\n";
+		}
+		print $xmlfh '    </dependency>', "\n";
+	}
+	foreach my $extradep (keys %extradeps)
+	{
+		print $xmlfh '    <dependency>', "\n";
+		print $xmlfh "      <name>$extradep</name>", "\n";
+		if ($extradeps{$extradep}{minimum_version})
+		{
+			print $xmlfh "      <minimum_version>$extradeps{$extradep}{minimum_version}</minimum_version>", "\n";
+		}
+		if ($extradeps{$extradep}{maximum_version})
+		{
+		print $xmlfh "      <maximum_version>$extradeps{$extradep}{maximum_version}</maximum_version>", "\n";
+		}
+		print $xmlfh '    </dependency>', "\n";
+	}
+	foreach my $nativedep (keys %nativedeps)
+	{
+		print $xmlfh '    <dependency>', "\n";
+		print $xmlfh "      <name>$nativedep</name>", "\n";
+		if ($nativedeps{$nativedep}{minimum_version})
+		{
+			print $xmlfh "      <minimum_version>$nativedeps{$nativedep}{minimum_version}</minimum_version>", "\n";
+		}
+		if ($nativedeps{$nativedep}{maximum_version})
+		{
+			print $xmlfh "      <maximum_version>$nativedeps{$nativedep}{maximum_version}</maximum_version>", "\n";
+		}
+		print $xmlfh '      <native/>', "\n";
+		print $xmlfh '    </dependency>', "\n";
+	}
+	# Insert an appropriate dependency on Perl itself
+	print $xmlfh '    <dependency>', "\n";
+	print $xmlfh "      <name>perl</name>", "\n";
+	print $xmlfh "      <minimum_version>", sprintf("%vd", $^V), "</minimum_version>", "\n";
+	print $xmlfh "      <maximum_version>$majordotminor.9999</maximum_version>", "\n";
+	print $xmlfh '    </dependency>', "\n";
+	print $xmlfh '  </dependencies>', "\n";
+	print $xmlfh '</tpkg>', "\n";
+	# Build package
+	system("tpkg --make $tpkgdir");
+}
+

data/bin/gem2tpkg

@@ -0,0 +1,445 @@
+#!/usr/bin/ruby -w
+
+# Ensure we can find tpkg.rb
+$:.unshift File.dirname(__FILE__)
+
+require 'fileutils' # FileUtils.cp, rm, etc.
+require 'tempfile'  # Tempfile
+require 'optparse'
+require 'shellwords'
+require 'tpkg'
+require 'facter'
+
+# Names of packages containing ruby and gems.  Dependencies on these
+# will be added to generated packages, so that if a user installs a gem
+# then tpkg will pull in ruby and gems.
+RUBYDEPS = ['ruby']
+# T_RUBY_BASE = "/home/t/ruby"
+T_RUBY_BASE = "#{Tpkg::DEFAULT_BASE}/#{RUBYDEPS.first}".freeze
+DEFAULT_GEM_COMMAND = "#{T_RUBY_BASE}/bin/gem"
+
+# Figure out rubygems library from ruby.
+# There might be several versions so get the latest one. We're assuming that
+# the version directories are named appropriately under lib/ruby/site_ruby.
+versions = Dir.glob(File.join("#{T_RUBY_BASE}", "lib", "ruby", "site_ruby", "*"))
+versions.sort!
+DEFAULT_RUBYGEMS_PATH = versions[-1]
+
+# Haven't found a Ruby method for creating temporary directories,
+# so create a temporary file and replace it with a directory.
+def tempdir(basename, tmpdir=Dir::tmpdir)
+  tmpfile = Tempfile.new(basename, tmpdir)
+  tmpdir = tmpfile.path
+  tmpfile.close!
+  Dir.mkdir(tmpdir)
+  tmpdir
+end
+
+# Handle command line arguments
+@gems = nil
+@gemver = nil
+@pkgver = 1
+@extradeps = {}
+@nativedeps = {}
+@installopts = []
+@buildopts = []
+@gemcmd = DEFAULT_GEM_COMMAND
+@rubygemspath = nil
+
+opts = OptionParser.new
+opts.banner = 'Usage: gem2tpkg [options] GEMNAME1 GEMNAME2 ...'
+opts.on('--version', '-v', '=VERSION', 'Version of gem to install') do |opt|
+  @gemver = "-v #{opt}"
+end
+opts.on('--package-version', '--pv', '=PKGVER', 'Package version to use in tpkg, defaults to 1') do |opt|
+  @pkgver = opt
+end
+opts.on('--extra-deps', '=EXTRADEPS', Array, 'Extra dependencies to add to the package') do |opt|
+  # Example: --extra-deps=foo,1.0,1.9999,bar,4.5,4.5,blah,,
+  while !opt.empty?
+    dep = opt.shift
+    # These are optional, shift will return nil if they aren't present
+    # and we'll handle that properly when creating tpkg.xml
+    depminver = opt.shift
+    depmaxver = opt.shift
+    @extradeps[dep] = {}
+    @extradeps[dep][:minimum_version] = depminver
+    @extradeps[dep][:maximum_version] = depmaxver
+  end
+end
+opts.on('--native-deps', '=NATIVEDEPS', Array, 'Native dependencies to add to the package') do |opt|
+  # Example: --native-deps=foo,1.0,1.9999,bar,4.5,4.5,blah,,
+  while !opt.empty?
+    dep = opt.shift
+    # These are optional, shift will return nil if they aren't present
+    # and we'll handle that properly when creating tpkg.xml
+    depminver = opt.shift
+    depmaxver = opt.shift
+    @nativedeps[dep] = {}
+    @nativedeps[dep][:minimum_version] = depminver
+    @nativedeps[dep][:maximum_version] = depmaxver
+  end
+end
+opts.on('--install-options', '=INSTALLOPTS', 'Extra options to gem install') do |opt|
+  @installopts = Shellwords.shellwords(opt)
+end
+opts.on('--build-options', '=BUILDOPTS', 'Extra options to gem build') do |opt|
+  @buildopts = Shellwords.shellwords(opt)
+end
+opts.on('--gem-cmd', '=GEMCMD', 'Path to gem command') do |opt|
+  @gemcmd = opt
+end
+opts.on('--rubygems-path', '=PATH', 'Path to rubygems library') do |opt|
+  @rubygemspath = opt
+end
+opts.on_tail("-h", "--help", "Show this message") do
+  puts opts
+  exit
+end
+
+# we now allow user to specifies multiple gems at the end of the command line arguments
+leftover = opts.parse(ARGV)
+@gems = leftover
+#if leftover.length == 1
+#  @gem = leftover.shift
+#else
+#  puts opts
+#  exit
+#end
+
+# require the correct rubygems based on what the user specifies
+@rubygemspath ||= DEFAULT_RUBYGEMS_PATH
+$:.unshift @rubygemspath unless @rubygemspath.nil?
+require 'rubygems'
+
+# Create the directory we want gem to install into
+@gemdir = tempdir('gem2tpkg')
+ENV['GEM_HOME'] = @gemdir
+ENV['GEM_PATH'] = @gemdir
+
+# Install the gem
+#geminst = [@gemcmd, 'install', @gems.join(" "), '--no-rdoc', '--no-ri']
+geminst = [@gemcmd, 'install', '--no-rdoc', '--no-ri'] | @gems
+if @gemver
+  geminst << @gemver
+end
+# Pass through any options the user specified, might be necessary for
+# finding libraries, etc.
+if !@installopts.empty?
+  geminst.concat(@installopts)
+end
+if !@buildopts.empty?
+  geminst << '--'
+  geminst.concat(@buildopts)
+end
+
+r = system(*geminst)
+if !r
+  abort('gem install failed')
+end
+
+@already_packaged = []
+def package(gem)
+  pkgfiles = []
+  
+  return pkgfiles if @already_packaged.include?(gem)
+  
+  puts "Packaging #{gem}"
+  
+  gemsdir = nil
+  #globdirs = Dir.glob(File.join(@gemdir, 'gems', "#{gem}-*"))
+  globdirs = Dir.glob(File.join(@gemdir, 'gems', "#{gem}-[0-9]*"))
+  if globdirs.length == 1
+    gemsdir = globdirs[0]
+  else
+    # I don't expect this to happen in the real world, if it does we'll
+    # have to figure out a better mechanism of isolating the correct
+    # directory.  I guess we could load all of the gemspecs in the
+    # specifications directory until we find one with the correct gem
+    # name in it.
+    abort File.join(@gemdir, 'gems', "#{gem}-*") + ' is abiguous'
+  end
+
+  # gemsdir will be something like /tmp/gem2tpkg.5833.0/gems/rake-0.8.4
+  # and the gemspec will be something like
+  # /tmp/gem2tpkg.5833.0/specifications/rake-0.8.4.gemspec.  So we
+  # use the basename of gemsdir as the core of the gemspec
+  # filename.
+  gemspecfile = File.join(@gemdir,
+                          'specifications',
+                           File.basename(gemsdir) + '.gemspec')
+  
+  # Load the gemspec
+  gemspec = Gem::Specification.load(gemspecfile)
+  
+  # Package any dependencies
+  # Example output:
+  # Gem rails-2.3.2
+  #  rake (>= 0.8.3)
+  #  activesupport (= 2.3.2)
+  #  activerecord (= 2.3.2)
+  #  actionpack (= 2.3.2)
+  #  actionmailer (= 2.3.2)
+  #  activeresource (= 2.3.2)
+  # Now that we're loading the gemspec we could read this out of the
+  # gemspec instead, but this is already written and working so I'm
+  # leaving it alone for now.
+  deps = {}
+  # gem dependency does something equivalent to /^gemname/ by default,
+  # i.e. matches against anything that starts with the specified name.
+  # We want to exactly match the gem in question.  Turns out that if you
+  # pass something that looks like a regex then gem dependency will use
+  # that instead.  See rubygems/commands/dependency_command.rb
+  IO.popen("#{@gemcmd} dependency /^#{Regexp.escape(gem)}$/") do |pipe|
+    pipe.each_line do |line|
+      next if line =~ /^Gem /  # Skip header line
+      next if line =~ /^\s*$/  # Skip blank lines
+
+      # Skip development dependencies for now.  We don't need them for
+      # running production code.
+      next if line =~ /, development\)$/
+      line.chomp!
+      # Example lines:
+      # These two are for the same installed state but different
+      # versions of gem:
+      #   activesupport (= 2.3.2)
+      #   activesupport (= 2.3.2, runtime)
+      depgem, operator, depver = line.split
+      operator.sub!(/^\(/, '')
+      depver.sub!(/\)$/, '')
+      depver.sub!(/,$/, '')
+      # Save the dependency info for tpkg.xml
+      # http://rubygems.org/read/chapter/16
+      deps[depgem] = {}
+      case operator
+      when '='
+        deps[depgem][:minimum_version] = depver
+        deps[depgem][:maximum_version] = depver
+      when '!='
+        # Not quite sure what to do with this one
+        abort "Unknown version dependency: #{line}"
+      when '>='
+        deps[depgem][:minimum_version] = depver
+      when '>'
+        # If the gem seems to follow the standard gem version convention
+        # we can achieve this by incrementing the build number
+        # http://rubygems.org/read/chapter/7
+        verparts = depver.split('.')
+        if depver =~ /^[\d\.]+/ && verparts.length <=3
+          verparts.map! { |v| v.to_i }
+          # Pad with zeros if necessary
+          (verparts.length...3).each { verparts << 0 }
+          verparts[2] += 1
+          minver = "#{verparts[0]}.#{verparts[1]}.#{verparts[3]}"
+          deps[depgem][:minimum_version] = minver
+        else
+          # Fall back to this, which isn't exactly correct but
+          # hopefully better than nothing
+          warn "Can't parse depver #{depver}, falling back to approximation"
+          deps[depgem][:minimum_version] = depver
+        end
+      when '<='
+        deps[depgem][:maximum_version] = depver
+      when '<'
+        # If the gem seems to follow the standard gem version convention
+        # we can achieve this by decrementing the build number
+        # http://rubygems.org/read/chapter/7
+        verparts = depver.split('.')
+        if depver =~ /^[\d\.]+/ && verparts.length <=3
+          verparts.map! { |v| v.to_i }
+          # Pad with zeros if necessary
+          (verparts.length...3).each { verparts << 0 }
+          if verparts[2] == 0
+            if verparts[1] == 0  # 1.0.0 -> 0.9999.9999
+              verparts[0] -= 1
+              verparts[1] = 9999
+              verparts[2] = 9999
+            else                 # 1.1.0 -> 1.0.9999
+              verparts[1] -= 1
+              verparts[2] = 9999
+            end
+          else                   # 1.1.1 -> 1.1.0
+            verparts[2] -= 1
+          end
+          maxver = "#{verparts[0]}.#{verparts[1]}.#{verparts[3]}"
+          deps[depgem][:maximum_version] = maxver
+        else
+          # Fall back to this, which isn't exactly correct but
+          # hopefully better than nothing
+          warn "Can't parse depver #{depver}, falling back to approximation"
+          deps[depgem][:maximum_version] = depver
+        end
+      when '~>'
+        # ~> 2.2 is equivalent to >= 2.2 and < 3
+        deps[depgem][:minimum_version] = depver
+        majorver = depver.split('.').first.to_i
+        maxver = "#{majorver}.9999.9999"
+        deps[depgem][:maximum_version] = maxver
+      end
+      # Package the dependency
+      pkgfiles.concat(package(depgem))
+    end
+  end
+  if !$?.success?
+    abort 'gem dependency failed'
+  end
+  
+  # The directory where we make our package
+  pkgdir = tempdir('gem2tpkg')
+  pkgbasedir = File.join(pkgdir, "/root/#{T_RUBY_BASE}/lib/ruby/gems/1.8")
+  FileUtils.mkdir_p(pkgbasedir)
+  pkggemdir = File.join(pkgbasedir, 'gems')
+  FileUtils.mkdir_p(pkggemdir)
+  pkgspecdir = File.join(pkgbasedir, 'specifications')
+  FileUtils.mkdir_p(pkgspecdir)
+  
+  # Copy the gems directory over
+  system("#{Tpkg::find_tar} -C #{File.dirname(gemsdir)} -cf - #{File.basename(gemsdir)} | #{Tpkg::find_tar} -C #{pkggemdir} -xpf -")
+  
+  # If a gem flags any files as executables a wrapper script is
+  # created by gem for each executable in a bin directory at
+  # the top level of the gem directory structure.  We want to
+  # copy those wrapper scripts into the package.
+  binfiles = []
+  gemspec.executables.each do |exec|
+    binfiles << File.join(@gemdir, 'bin', exec)
+  end
+  if !binfiles.empty?
+    bindir = "#{pkgdir}/root/#{T_RUBY_BASE}/bin"
+    FileUtils.mkdir_p(bindir)
+    binfiles.each do |binfile|
+      FileUtils.cp(binfile, bindir, :preserve => true)
+    end
+  end
+  
+  # Copy over the gemspec file
+  FileUtils.cp(gemspecfile, pkgspecdir, :preserve => true)
+  
+  # Add tpkg.xml
+  os = nil
+  arch = nil
+  File.open(File.join(pkgdir, 'tpkg.xml'), 'w') do |file|
+    file.puts '<?xml version="1.0" encoding="UTF-8"?>'
+    file.puts '<!DOCTYPE tpkg SYSTEM "http://tpkg.sourceforge.net/tpkg-1.0.dtd">'
+    file.puts '<tpkg>'
+    file.puts "  <name>gem-#{gem}</name>"
+    file.puts "  <version>#{gemspec.version.to_s}</version>"
+    file.puts "  <package_version>#{@pkgver}</package_version>"
+    file.puts '  <maintainer>gem2tpkg</maintainer>'
+    # If the gemspec lists any extensions then the package has native
+    # code and needs to be flagged as specific to the OS and architecture
+    if gemspec.extensions && !gemspec.extensions.empty?
+      os = Tpkg::get_os
+      if os =~ /RedHat-(.*)/
+        os = os + ",CentOS-#{$1}"
+      elsif os =~ /CentOS-(.*)/
+        os = os + ",RedHat-#{$1}"
+      end
+      arch = Facter['hardwaremodel'].value
+      file.puts "  <operatingsystem>#{os}</operatingsystem>"
+      file.puts "  <architecture>#{arch}</architecture>"
+    end
+    if !deps.empty? ||
+       !@extradeps.empty? || !@nativedeps.empty? ||
+       !RUBYDEPS.empty?
+      file.puts '  <dependencies>'
+      deps.each do |depgem, depvers|
+        file.puts '    <dependency>'
+        file.puts "      <name>gem-#{depgem}</name>"
+        if depvers[:minimum_version]
+          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
+        end
+        if depvers[:maximum_version]
+          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
+        end
+        file.puts '    </dependency>'
+      end
+      @extradeps.each do |extradep, depvers|
+        file.puts '    <dependency>'
+        file.puts "      <name>#{extradep}</name>"
+        if depvers[:minimum_version]
+          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
+        end
+        if depvers[:maximum_version]
+          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
+        end
+        file.puts '    </dependency>'
+      end
+      @nativedeps.each do |nativedep, depvers|
+        file.puts '    <dependency>'
+        file.puts "      <name>#{nativedep}</name>"
+        if depvers[:minimum_version]
+          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
+        end
+        if depvers[:maximum_version]
+          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
+        end
+        file.puts '      <native/>'
+        file.puts '    </dependency>'
+      end
+      RUBYDEPS.each do |rubydep|
+        file.puts '    <dependency>'
+        file.puts "      <name>#{rubydep}</name>"
+        file.puts '    </dependency>'
+      end
+      file.puts '  </dependencies>'
+    end
+    file.puts '</tpkg>'
+  end
+  
+  # Make package
+  pkgfile = Tpkg::make_package(pkgdir)
+  # If the package is OS-specific then rename the file to reflect that
+  if os
+    # Examples:
+    # FreeBSD-7 -> freebsd7
+    # RedHat-5 -> redhat5
+    # CentOS-5 -> redhat5
+    fileos = Tpkg::get_os.sub('CentOS', 'RedHat').downcase.sub('-', '')
+    newpkgfile = File.join(
+                   File.dirname(pkgfile),
+                   "#{File.basename(pkgfile, '.tpkg')}-#{fileos}-#{arch}.tpkg")
+    File.rename(pkgfile, newpkgfile)
+    pkgfile = newpkgfile
+  end
+  pkgfiles << pkgfile
+  
+  # Cleanup
+  FileUtils.rm_rf(pkgdir)
+ 
+  @already_packaged << gem
+  pkgfiles
+end
+
+# Count the number of gems installed
+gemcount = 0
+IO.popen("#{@gemcmd} list") do |pipe|
+  pipe.each_line do |line|
+    next if line.include?('***')  # Skip header line
+    next if line =~ /^\s*$/       # Skip blank lines
+    gemcount += 1
+  end
+end
+if gemcount == 0
+  abort "Zero gems installed according to gem list?"
+end
+
+pkgfiles = []
+@gems.each do | gem |
+  pkgfiles |=  package(gem)
+end
+# Make sure the package method made as many packages as there were gems
+# installed
+if pkgfiles.length != gemcount
+  abort "gem count (#{gemcount}) vs pkg count (#{pkgfiles.length}) mismatch"
+end
+
+# Tell the user what packages were created
+puts 'The following packages were created:'
+pkgfiles.each do |pkgfile|
+  puts pkgfile
+end
+
+# Cleanup
+FileUtils.rm_rf(@gemdir)
+