devball 0.3

data/README

@@ -0,0 +1,14 @@
+DevBall Builder
+---
+This is a tool for building a devball. A devball is a self-contained set of packages that can be portably be moved from one binary-compatible machine to another.
+
+Usage
+---
+- Create a directory with pkgspecs and the accompanying tarballs/gem files/etc.
+- Run "devball build {path}" to build the packages and setup the devball directory
+- Use "devball push -p {rsync target} -n {build name}" to push your devball into an rsync repository
+- Use "devball pull -p {rsync target} -n {build name}" to pull a devball down from an rsync repository
+
+Examples
+---
+(To be added)

data/bin/devball

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+if (File.exists?("#{__FILE__}-#{ARGV[0]}"))
+	$0 += " " + ARGV[0]
+	load("#{__FILE__}-#{ARGV.shift}")
+	exit(0)
+end
+
+puts("Unknown devball command #{ARGV[0]}")
+exit(1)

data/bin/devball-build

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+# Builds our package environment based on the .pkgspec files in packages
+
+require 'devball/initialization'
+
+module DevBall
+	should_clean = false
+	clean_build_dirs = true
+	explicit_packages = nil
+	build = true
+	force = false
+	only = false
+
+	$build_dir = "/tmp/devball-build"
+
+	configure do |opts|
+		opts.on("-b", "--build-dir BUILD_DIR", "Specify where to use as a scratch directory for building. Defaults to /tmp/devball-build") do |build_dir|
+			$build_dir = build_dir
+		end	
+		opts.on("-c", "--clean-install", "Remove built devball directory before starting.") do
+			should_clean = true
+		end
+		opts.on("-L", "--leave-build-dirs", "Leave intermediate build directories alone after installing (for debugging)") do
+			clean_build_dirs = false
+		end
+		opts.on("-N", "--no-build", "Don't actually build the devball, just list what would be built.") do
+			build = false
+		end
+		opts.on("-o", "--only PKGNAME,PKGNAME,PKGNAME...", "Only build the packages specified on the command line (but not their deps)") do |pkgnames|
+			only = true
+			explicit_packages = pkgnames.collect do |pkgname|
+				if (regex_match = /^\/(.*)\/$/.match(pkgname))
+					Regexp.new(regex_match[1])
+				else
+					pkgname
+				end			
+			end
+		end
+		opts.on("-f", "--force", "Build ALL packages, even if they're already installed in the devball.") do
+			force = true
+		end
+	end
+	
+	packages = PkgSpec::Base.load_packages($package_dir, explicit_packages, only);
+	if (!force)
+		packages.delete_if {|pkg| File.directory?("#{$install_base}/packages/#{pkg}") }
+	end
+	puts("Installing packages: #{packages.join(', ')}")
+	puts("Into #{$install_base}")
+
+	exit(0) if (!build)
+
+	if (!system("mkdir", "-p", $build_dir))
+		puts("Could not create build directory.")
+		exit(150)
+	end
+
+	if (File.exists?($install_base) && should_clean)
+		system("rm", "-rf", "#{$install_base}/*")
+	end
+
+	if (!system("mkdir", "-p", $install_base))
+		puts("Could not create target directory.")
+		puts("You will probably need to create the directory and set permissions yourself by running:")
+		puts("sudo mkdir -p #{$install_base}")
+		puts("sudo chown #{ENV['USER']}: #{$install_base}")
+		exit(250)
+	end
+
+	# commonly needed environment variables.
+	ENV['CFLAGS'] = (ENV['CFLAGS'] || "") + " -I#{$install_base}/include -fPIC"
+	ENV['CXXFLAGS'] = (ENV['CXXFLAGS'] || "") + " -I#{$install_base}/include -fPIC"
+	ENV['LDFLAGS'] = (ENV['LDFLAGS'] || "") + " -L#{$install_base}/lib -fPIC"
+	ENV['PATH'] = "#{$install_base}/bin:" + (ENV['PATH'] || "")
+	ENV['RUBYOPT'] = '' # clear this out. It blows stuff up.
+
+	packages.each {|package|
+		package.remove_build()
+		related_pkgs = []
+		begin
+			puts("Extracting #{package}")
+			package.step_extract()
+			puts("Patching #{package}")
+			package.step_patch()
+			puts("Setting environment for #{package}")
+			package.step_environment_setup()
+			puts("Configuring #{package}")
+			package.step_configure()
+			puts("Building #{package}")
+			package.step_build()
+			puts("Installing #{package}")
+			package.remove_install()
+			begin
+				FileUtils.mkdir_p(package.package_install_dir) # precreate the package directory so it always exists.
+				related_pkgs = package.step_install()
+			rescue Exception
+				puts("Error installing #{package}. Cleaning up the install dir.")
+				package.remove_install()
+				system("rm", "-rf", package.package_install_dir)
+				raise
+			end
+		ensure
+			if (clean_build_dirs)
+				puts("Removing build directory for #{package}")
+				package.remove_build()
+			end
+		end
+		puts("Setting up links for #{package}")
+		package.step_setup_links()
+		if (related_pkgs.kind_of?(Array))
+			related_pkgs.each {|related|
+				PkgSpec::Base.find(related).step_setup_links()
+			}
+		end
+	}
+
+	puts("Done installing packages #{packages.join(', ')}.")
+end

data/bin/devball-pull

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# Pushed a built devball to an rsync target for later fetching by devball-pull
+
+require 'devball/initialization'
+
+module DevBall
+	config = {
+#		:path => nil,
+#		:username => nil,
+#		:build_name => nil,
+#		:no_push => nil,
+	}
+	
+	configure do |opts|
+		opts.banner += "\n Will pull from {TARGET_PATH}{BUILD_NAME}."
+		
+		opts.on("-n", "--name BUILD_NAME", "Name the build for pushing to rsync server.") do |build_name|
+			config[:build_name] = build_name
+		end
+		opts.on("-p", "--path TARGET_PATH", "Push to the rsync path specified with the build name specified in -n.") do |rsync_server|
+			config[:path] = rsync_server
+		end
+		opts.on("-u", "--username USERNAME", "Username to use when connecting to rsync.") do |username|
+			config[:username] = username
+		end
+		opts.on("-N", "--no-pull", "Don't actually pull, just tell me where it'll be pushing to.") do 
+			config[:no_pull] = true
+		end
+	end
+	
+	config = $config[:rsync][:pull].merge(config) if ($config[:rsync] && $config[:rsync][:pull])
+	
+	if (!config[:build_name] || !config[:path])
+		puts("You must specify a build name and rsync path to push to.")
+		exit(1)
+	end
+	
+	if (config[:username])
+		config[:path] = config[:path].gsub(%r{^rsync://}, "rsync://#{config[:username]}@")
+	end
+
+	puts("Pulling devball from rsync path #{config[:path]}#{config[:build_name]}")
+	exit(0) if config[:no_pull]
+	
+	if (!system("mkdir", "-p", $install_base))
+		puts("Could not create target directory.")
+		puts("You will probably need to create the directory and set permissions yourself by running:")
+		puts("sudo mkdir -p #{$install_base}")
+		puts("sudo chown #{ENV['USER']}: #{$install_base}")
+		exit(250)
+	end
+
+	system("rsync", "-a", "--delete", "#{config[:path]}#{config[:build_name]}", "#{$install_base}")
+
+	# now take the list of packages we pulled down, load their package objects, and setup links.
+	packages = PkgSpec::Base.load_packages($package_dir, nil, false);
+	Dir["#{$install_base}/packages/*"].each {|pkg_name|
+		pkg_name = %r{/([^/]+)$}.match(pkg_name)[1]
+		package = PkgSpec::Base.find(pkg_name)
+		if (!package)
+			raise "Unknown package #{pkg_name} pulled from devball server."
+		end
+		puts("Setting up links for #{pkg_name}")
+		package.step_setup_links()
+	}
+end

data/bin/devball-push

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Pushed a built devball to an rsync target for later fetching by devball-pull
+
+require 'devball/initialization'
+
+module DevBall
+	config = {
+#		:path => nil,
+#		:username => nil,
+#		:build_name => nil,
+#		:no_push => nil,
+	}
+	
+	configure do |opts|
+		opts.banner += "\n Will push to {TARGET_PATH}{BUILD_NAME}.\n Must have a built devball to push anything."
+		
+		opts.on("-n", "--name BUILD_NAME", "Name the build for pushing to rsync server.") do |build_name|
+			config[:build_name] = build_name
+		end
+		opts.on("-p", "--path TARGET_PATH", "Push to the rsync path specified with the build name specified in -n.") do |rsync_server|
+			config[:path] = rsync_server
+		end
+		opts.on("-u", "--username USERNAME", "Username to use when connecting to rsync.") do |username|
+			config[:username] = username
+		end
+		opts.on("-N", "--no-push", "Don't actually push, just tell me where it'll be pushing to.") do 
+			config[:no_push] = true
+		end
+	end
+
+	config = $config[:rsync][:push].merge(config) if ($config[:rsync] && $config[:rsync][:push])
+
+	if (!config[:build_name] || !config[:path])
+		puts("You must specify a build name and rsync path to push to.")
+		exit(1)
+	end
+	
+	if (config[:username])
+		config[:path] = config[:path].gsub(%r{^rsync://}, "rsync://#{config[:username]}@")
+	end
+
+	puts("Pushing devball to rsync path #{config[:path]}#{config[:build_name]}")
+	exit(0) if config[:no_push]
+
+	system("rsync", "-a", "--delete", "#{$install_base}/packages", "#{config[:path]}#{config[:build_name]}")
+end

data/lib/devball/initialization.rb

@@ -0,0 +1,35 @@
+require 'optparse'
+require 'yaml'
+require 'devball/pkgspec/base'
+
+module DevBall
+	# Loads all the config options relevant to all devball commands. Yields
+	# an optparse object for the specific command to add options to.
+	def self.configure(argv = ARGV)
+		$install_base = nil
+
+		opts = OptionParser.new do |opts|
+			opts.banner = "Usage: #{$0} [options] package_dir"
+		
+			opts.on_tail("-h", "--help", "Show help screen") do
+				puts opts
+				exit(0)
+			end
+			
+			yield opts
+		end
+		
+		opts.parse! argv
+		
+		$package_dir = ARGV.shift || raise(ArgumentError, "No package bundle directory named.")
+		$package_name = File.basename($package_dir)
+
+		$config = {}
+		if (File.exists? "#{$package_dir}/config.yaml")
+			$config = YAML.load_file("#{$package_dir}/config.yaml")
+			$package_name = $config[:package_name] || $package_name
+		end
+
+		$install_base = "/#{$package_name}"
+	end
+end

data/lib/devball/pkgspec/base.rb

@@ -0,0 +1,342 @@
+# defines a bunch of helper functions as well as the main steps for building a package
+# These steps are:
+# - step_extract
+# - step_patch
+# - step_environment_setup
+# - step_configure
+# - step_build
+# - step_install
+# - step_setup_links
+# There are also two that are involved in removing the resulting files.
+# - remove_build
+# - remove_install
+# Derived classes should also describe their dependency tree through the
+# PkgSpec::Base.depends_on function.
+require 'fileutils'
+module DevBall
+	module PkgSpec
+		class Error < Exception; end
+		class Undefined < Error; end
+		class PackageLoadError < Error; end
+		class ExtractFailed < Error; end
+		class ConfigureFailed < Error; end
+		class BuildFailed < Error; end
+		class InstallFailed < Error; end
+		class RemoveFailed < Error; end
+		
+		# Autoload arbitrary devball pkgspec-types through const_missing
+		def self.const_missing(name)
+			autoloading = (Thread.current[:autoloading] ||= {})
+			if (autoloading[name])
+				raise NameError, "uninitialized constant DevBall::PkgSpec::#{name} (autoload already tried to find it)"
+			end
+			autoloading[name] = true
+			
+			begin
+				filename = name.to_s.gsub(/^[A-Z]/) {|a| a.downcase }.gsub(/[A-Z]/) {|a| "_#{a.downcase}" }
+				require 'devball/pkgspec/' + filename
+				if (!const_defined?(name))
+					raise NameError, "uninitialized constant DevBall::PkgSpec::#{name} (autoload found file but file did not define class)"
+				end
+				return const_get(name)
+			rescue LoadError
+				raise NameError, "uninitialized constant DevBall::PkgSpec::#{name} (autoload failed to find matching file)"				
+			ensure
+				autoloading[name] = false
+			end
+		end
+
+		class Base
+			class <<self
+				def load_packages(dir, explicit, only_explicit = false)
+					# load all the packagespecs
+					@packages ||= {}
+					@install_packages ||= {}
+					Dir["#{dir}/*.pkgspec"].each {|f|
+						load "#{Dir.getwd}/#{f}"
+					}
+
+					def explicit.include?(str)
+						each {|i|
+							if (i === str)
+								return true
+							end
+						}
+						return false
+					end
+			
+					@packages_inorder = @install_packages.collect {|name, pkg|
+						if (deps = pkg.recursive_depends_on)
+							[deps, name].flatten
+						else
+							name
+						end
+					}.flatten.uniq.collect {|pkgname|
+						if (!only_explicit || explicit.include?(pkgname))
+							@packages[pkgname] || raise(Error, "Unknown package #{pkgname} in package list (#{@packages.keys.join(",")})")
+						else
+							nil
+						end
+					}.compact
+					return @packages_inorder
+				end
+				attr :packages_inorder
+		
+				def find(name)
+					@packages ||= {}
+			
+					return @packages[name]
+				end
+		
+				def depends_on(*deps)
+					@deps ||= []
+					@deps.push(*deps) if (deps.length > 0)
+
+					deps = []
+					if (superclass && superclass.respond_to?(:depends_on))
+						deps.push(*superclass.depends_on)
+					end
+					deps.push(*@deps)
+					deps
+				end
+
+				def register_package(klass, name, required)
+					@packages ||= {}
+					@packages[name] = klass
+					if (required)
+						@install_packages ||= {}
+						@install_packages[name] = klass
+					end
+				end
+				attr :ball
+				def set_ball(name, required = true)
+					@ball = name
+					@instance = self.new
+					PkgSpec::Base.register_package(@instance, @instance.package_name, required)
+				end
+				# defines it as a library that is only required if somethind depended on it.
+				def set_lib_ball(name)
+					set_ball(name, false)
+				end
+		
+				attr :patches
+				def set_patch(*patches)
+					@patches ||= []
+					@patches += patches
+				end
+			end
+			def ball
+				return self.class.ball
+			end
+			def depends_on		
+				return self.class.depends_on
+			end
+			def recursive_depends_on
+				return self.class.depends_on.collect {|dep|
+					pkg = PkgSpec::Base.find(dep) || raise(PackageLoadError, "Package #{to_s} depends on #{dep} which doesn't exist.")
+					[pkg.recursive_depends_on, dep]
+				}.flatten
+			end
+	
+			def ball_file_name()
+				return "#{$package_dir}/#{ball}"
+			end
+			# extracts the ball to the correct place in the builddir
+			def step_extract()
+				raise Undefined, "Behaviour undefined for extracting the ball"
+			end
+	
+			def step_patch()
+				if (File.directory?(build_dir_name) && self.class.patches && self.class.patches.length)
+					orig = Dir.getwd
+					Dir.chdir(build_dir_name) {|dir|
+						self.class.patches.each {|patch|
+							system("patch -p1 < #{orig}/#{$package_dir}/#{patch}") || raise(PatchFailed, "Patch #{patch} failed to apply. Errno #{$?}")
+						}
+					}
+				end
+			end
+	
+			# get the name of the ball without extention
+			def ball_version()
+				ball().gsub(/^(.*)\.(gem|tar\.gz|tgz|tar\.bz2)$/, '\1')
+			end
+	
+			# get the name of the ball without version. Cuts off after the first hyphen
+			def ball_name()
+				ball_version().gsub(/^([^\-]+)$/, '\1')
+			end
+	
+			# get the name of the subdirectory the ball was extracted to
+			# provides a default implementation that uses ball() and takes off known extensions
+			# on the assumption that its name will be derived from the ball name that way.
+			# If that's not true, it should be overriden
+			def build_dir_name()
+				return "#{$build_dir}/#{ball_version}"
+			end
+	
+			# get the name of the package without any version information. Default
+			# implementation bases it on the class name.
+			def package_name()
+				package_name = self.class.name.to_s
+				package_name = package_name.gsub(/^(.+?)(Package)?$/, '\1')
+				return package_name
+			end
+			def to_s()
+				package_name()
+			end
+	
+			# Returns the directory the package will be installed in.
+			def package_install_dir()
+				return "#{$install_base}/packages/#{package_name}"
+			end
+	
+			# configure options to pass to ./configure. The default step_configure function
+			# uses this, but derived versions don't have to, but whatever they do should
+			# have the same effect as the prefix set by the hash this returns.
+			# if this is overloaded, you should merge your options with super()
+			def configure_params()
+				return {:prefix=>package_install_dir}
+			end
+	
+			def step_environment_setup()
+			end
+	
+			def configure_script_name()
+				"./configure"
+			end
+	
+			# do the configure step. The only requirement is that this end up installing things
+			# in /$install_base/packages/#{package_name}. The default implementation runs ./configure in
+			# the build dir with the results of configure_params.
+			def step_configure()
+				Dir.chdir(build_dir_name) {|dir|
+					params = configure_params.collect {|key, val| 
+						if (val)
+							"--#{key}=#{val}" 
+						else
+							"--#{key}"
+						end
+					}
+					if (!system(configure_script_name, *params))
+						raise ConfigureFailed, "Configuration failed with error: #{$?}"
+					end
+				}
+			end
+
+			# targets for the build call to make to use
+			def build_targets()
+				return ["all"]
+			end
+
+			def build_concurrent?()
+				return true
+			end
+	
+			# do the build step. Default implementation is to simply run make in the build dir.
+			def step_build()
+				Dir.chdir(build_dir_name) {|dir|
+					args = []
+					args.push("-j4") if build_concurrent?
+					args += build_targets
+					if (!system("make", *args))
+						raise BuildFailed, "Build failed with error: #{$?}"
+					end
+				}
+			end
+	
+			def install_targets()
+				return ["install"]
+			end
+
+			# do the install step. Default implementation is to simply run "make install" in the build dir
+			def step_install()
+				Dir.chdir(build_dir_name) {|dir|
+					if (!system("make", *install_targets))
+						raise InstallFailed, "Install failed with error: #{$?}"
+					end
+				}
+				return []
+			end
+	
+			# Returns any explicit filename translations that should be performed on a file when linking
+			# it into the right place in the tree.
+			def link_mappings()
+				return {}
+			end
+	
+			def install_service_links(base_from)
+				Dir[File.join(base_from, "*")].each {|service|
+					supervise_dir = File.join("/var#{$install_base}/supervise", File.basename(service))
+					begin
+						File.delete(File.join(service, "supervise"))
+					rescue; end
+					File.symlink(supervise_dir, File.join(service, "supervise"))
+					if (File.directory?(File.join(service, "log")))
+						begin
+							File.delete(File.join(service, "log", "supervise"))
+						rescue; end
+						File.symlink("#{supervise_dir}-log", File.join(service, "log", "supervise"))
+					end
+				}
+			end
+	
+			# internal implementation of setting the links up for a given directory.
+			# pass nil into subdir to suppress recursion.
+			def install_links(base_from, base_into, subdir)
+				recurse = subdir
+				subdir = "" if !subdir
+				Dir[File.join(base_from, subdir, "*")].each {|file|
+					stat = File.lstat(file)
+					if (stat.directory? && recurse)
+						FileUtils.mkdir_p(File.join(base_into, subdir, File.basename(file)))
+						install_links(base_from, base_into, File.join(subdir, File.basename(file)))
+					end
+					if (!stat.directory?)
+						target = File.join(base_into, subdir, File.basename(file))
+						begin
+							File.delete(target)
+						rescue
+						end
+						File.symlink(file, target)
+					end
+				}
+			end
+	
+			# Build the appropriate links for the package so it can be run properly from /nexopia
+			def step_setup_links()
+				install_links(package_install_dir, "#{$install_base}", nil)
+				FileUtils.mkdir_p("#{$install_base}/bin")
+				install_links(File.join(package_install_dir, "bin"), "#{$install_base}/bin", "")
+				install_links(File.join(package_install_dir, "sbin"), "#{$install_base}/bin", "")
+				install_links(File.join(package_install_dir, "libexec"), "#{$install_base}/bin", "")
+				FileUtils.mkdir_p("#{$install_base}/lib")
+				install_links(File.join(package_install_dir, "lib"), "#{$install_base}/lib", "")
+				FileUtils.mkdir_p("#{$install_base}/include")
+				install_links(File.join(package_install_dir, "include"), "#{$install_base}/include", "")
+				FileUtils.mkdir_p("#{$install_base}/man")
+				install_links(File.join(package_install_dir, "man"), "#{$install_base}/man", "")
+				FileUtils.mkdir_p("#{$install_base}/etc")
+				install_links(File.join(package_install_dir, "etc"), "#{$install_base}/etc", "")
+		
+				FileUtils.mkdir_p("#{$install_base}/service-privileged")
+				install_service_links(File.join(package_install_dir, "service-privileged"))
+				install_links(File.join(package_install_dir, "service-privileged"), "#{$install_base}/service-privileged", "")
+				FileUtils.mkdir_p("#{$install_base}/service-required")
+				install_service_links(File.join(package_install_dir, "service-required"))
+				install_links(File.join(package_install_dir, "service-required"), "#{$install_base}/service-required", "")
+				FileUtils.mkdir_p("#{$install_base}/service-optional")
+				install_service_links(File.join(package_install_dir, "service-optional"))
+				install_links(File.join(package_install_dir, "service-optional"), "#{$install_base}/service-optional", "")
+			end
+	
+			def remove_build()
+				system("rm", "-rf", build_dir_name) || raise(RemoveFailed, "Could not delete existing build directory.")
+			end
+	
+			def remove_install()
+				system("rm", "-rf", package_install_dir) || raise(RemoveFailed, "Could not delete installed directory.")
+			end
+		end
+	end
+end

data/lib/devball/pkgspec/djb.rb

@@ -0,0 +1,73 @@
+require 'ftools'
+
+module DevBall
+	module PkgSpec
+		class Djb < Tarball
+			def extract_dir_name()
+				return build_dir_name
+			end
+			def package_build_dir_name()
+				return extract_dir_name + "/#{type}/#{ball_version}"
+			end
+	
+			# use this to set the type of the package in djb's world (ie. admin)
+			def self.set_type(type)
+				@type = type
+			end
+			def self.type()
+				return @type
+			end
+			def type()
+				return self.class.type
+			end
+	
+			def step_configure()
+				# look for makefiles and turn off -static flags in them. (ugh)
+				if (RUBY_PLATFORM =~ /darwin/)
+					Dir[package_build_dir_name() + "/**/Makefile"].each {|makefile|
+						File.rename(makefile, makefile + ".old")
+						File.open(makefile + ".old", "r") {|fin|
+							File.open(makefile, "w") {|fout|
+								fin.each {|line|
+									fout.puts(line.gsub(/\-static/, ''))
+								}
+							}
+						}
+					}
+				end
+			end
+	
+			def step_build()
+				Dir.chdir(package_build_dir_name()) {|dir|
+					# build source
+					system("package/compile") || raise(BuildFailed, "Build of djb package failed: #{$?}")
+					# build man pages
+					Dir.chdir("man") {|dir|
+						Dir["*.?"].each {|manfile|
+							system("gzip", manfile)
+						}
+					}
+				}
+			end
+	
+			def step_install()
+				# get commands from command/ and put them in the package install dir's bin directory
+				Dir.chdir(package_build_dir_name) {|dir|
+					# install the commands as specified by package/commands.
+					commands = IO.readlines("package/commands")
+					FileUtils.mkdir_p(package_install_dir + "/bin")
+					commands.each {|command|
+						FileUtils.copy("compile/" + command.chomp, package_install_dir + "/bin")
+					}
+					# install the man pages
+					Dir["man/*.?.gz"].each {|manpage|
+						mantype = /(.+)\.([0-8])\.gz/.match(manpage)
+						FileUtils.mkdir_p(package_install_dir + "/man/man#{mantype[2]}")
+						FileUtils.copy(manpage, package_install_dir + "/man/man#{mantype[2]}")
+					}
+				}
+				return []
+			end
+		end
+	end
+end

data/lib/devball/pkgspec/gem.rb

@@ -0,0 +1,98 @@
+module DevBall
+	module PkgSpec
+		class Gem < Base
+			if ENV['RUBINIUS']
+				depends_on "Rubinius"
+			elsif ENV['REE']
+				depends_on "Ruby"
+			else
+				depends_on "RubyGems"
+			end
+	
+			def step_extract()
+				# whether the gem is a local file or fetched from rubyforge, we don't extract it.
+			end
+	
+			def step_configure()
+				# gems are all three steps in one at install time.
+			end
+	
+			def step_build()
+				# gems are all three steps in one at install time.
+			end
+	
+			def configure_params()
+				return {} # no need for prefix
+			end
+	
+			# override to specify a different gem repository. Default returns nil and indicates to use the standard rubyforge repo.
+			def gem_repository()
+				return nil
+			end
+	
+			def step_install()
+				Dir.chdir($package_dir) {|dir|
+					params = configure_params.collect {|key, val|
+						if (val)
+							"--#{key}=#{val}"
+						else
+							"--#{key}"
+						end
+					}
+			
+					if (params.length)
+						params.unshift("--")
+					end
+
+					if (gem_repository)
+						params.unshift(gem_repository)
+						params.unshift("--source")
+					end
+			
+					if (ENV['RUBINIUS'])
+		#				params = ["rbx", "gem", "install", "--install-dir=/nexopia/packages/Rubinius/lib/rubinius/gems/1.8", ball, *params].collect {|i| %Q{"#{i}"} }
+						params = ["rbx", "gem", "install", ball, *params].collect {|i| %Q{"#{i}"} }
+					else
+						params = ["gem", "install", ball, *params].collect {|i| %Q{"#{i}"} }
+					end
+					# and here this gets complicated, since gems don't return an error code if they fail. They just talk about it on their output.
+					success = false
+					errors = []
+					open("|#{params.join(' ')} 2>&1", "r") {|io|
+						io.each {|line|
+							puts(line)
+							if (match = /ERROR:\s+(.+)$/.match(line))
+								errors.push(match[1])
+							end
+							if (match = /^[0-9]+ gems? installed/.match(line))
+								success = true
+							end
+							if (match = /^Successfully installed/.match(line))
+								success = true
+							end
+						}
+					}
+					if (!success)
+						raise(InstallFailed, "Could not install gem: #{errors.join(', ')}")
+					end
+				}
+				if (ENV['JRUBY'])
+					return "JRuby"
+				elsif (ENV['Rubinius'])
+					return "Rubinius"
+				else
+					return "Ruby"
+				end
+			end
+	
+			def step_uninstall()
+				if (ENV['RUBINIUS'])
+					system("rbx", "gem", "uninstall", ball())
+				else
+					system("gem", "uninstall", ball())
+				end
+				super()
+			end
+		end
+	end
+end

data/lib/devball/pkgspec/pecl.rb

@@ -0,0 +1,35 @@
+module DevBall
+	module PkgSpec
+		class Pecl < Base
+			depends_on "Php"
+	
+			def step_extract()
+			end
+	
+			def step_configure()
+				# pecl is all three steps in one at install time.
+			end
+	
+			def step_build()
+				# gems is all three steps in one at install time.
+			end
+	
+			def step_install()
+				Dir.chdir($package_dir) {|dir|
+					if(!system("pecl", "install", ball()))
+						raise(InstallFailed, "Could not install pecl package: #{$?}")
+					end
+					if(!system("pecl", "list-files", "apc")) # pecl install doesn't seem to always return an error code if it fails, so double check
+						raise(InstallFailed, "Could not install pecl package: #{$?}")
+					end
+				}
+				return ["Php"]
+			end
+	
+			def step_uninstall()
+				system("pecl", "uninstall", ball())
+				super()
+			end
+		end
+	end
+end

data/lib/devball/pkgspec/simple_dir.rb

@@ -0,0 +1,9 @@
+module DevBall
+	module PkgSpec
+		class SimpleDir < Base
+			def step_extract()
+				system("cp", "-r", ball_file_name, build_dir_name) || raise(ExtractFailed, "Failed to copy ball into build.")
+			end
+		end
+	end
+end

data/lib/devball/pkgspec/tarball.rb

@@ -0,0 +1,33 @@
+module DevBall
+	module PkgSpec
+		class Tarball < Base
+			# overload if this package is known to extract in a funny way (ie. no top level directory included).
+			# default is to extract directly in the build directory.
+			def extract_dir_name()
+				File.dirname(build_dir_name)
+			end
+	
+			def step_extract()
+				# figure out what type of ball it is:
+				ext = ball_file_name.match(/(\.tar|\.tar\.gz|\.tgz|\.tar\.bz2)$/)
+				if (!ext)
+					raise ExtractFailed, "Could not determine type of tarball."
+				end
+				ext = ext[1]
+				args = "xvf"
+				case ext
+				when ".tar.gz", ".tgz":
+					args = "z" + args
+				when ".tar.bz2"
+					args = "j" + args
+				end
+		
+				wd = Dir.getwd
+				FileUtils.mkdir_p(extract_dir_name)
+				Dir.chdir(extract_dir_name) {|dir|
+					system("tar", "-#{args}", "#{wd}/#{ball_file_name}") || raise(ExtractFailed, "Could not extract tarball, error #{$?}")
+				}
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: devball
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Graham Batty
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: graham at nexopia dot com
+executables: 
+- devball-build
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- bin/devball
+- bin/devball-build
+- bin/devball-pull
+- bin/devball-push
+- lib/devball
+- lib/devball/initialization.rb
+- lib/devball/pkgspec
+- lib/devball/pkgspec/base.rb
+- lib/devball/pkgspec/djb.rb
+- lib/devball/pkgspec/gem.rb
+- lib/devball/pkgspec/pecl.rb
+- lib/devball/pkgspec/simple_dir.rb
+- lib/devball/pkgspec/tarball.rb
+- lib/devball/pkgspec/test.rb
+- README
+has_rdoc: true
+homepage: http://github.com/nexopia/devball
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A tool for building a self-contained set of packages that can be portably be moved from one binary-compatible machine to another.
+test_files: []
+