packaging 0.99.0

data/spec/lib/packaging/util/version_spec.rb

@@ -0,0 +1,123 @@
+# -*- ruby -*-
+require 'spec_helper'
+
+# Spec tests for Pkg::Util::Version
+#
+# rubocop:disable Metrics/BlockLength
+describe 'Pkg::Util::Version' do
+  context '#versionbump' do
+    let(:version_file) { 'thing.txt' }
+    let(:version) { '1.2.3' }
+    let(:orig_contents) { "abcd\nVERSION = @DEVELOPMENT_VERSION@\n" }
+    let(:updated_contents) { "abcd\nVERSION = #{version}\n" }
+
+    it 'should update the version file contents accordingly' do
+      Pkg::Config.config_from_hash(project: 'foo', version_file: version_file)
+      allow(IO).to receive(:read).with(version_file) { orig_contents }
+      allow(Pkg::Config).to receive(:version) { version }
+      version_file_to_write = double('file')
+      expect(File).to receive(:open).with(version_file, 'w').and_yield(version_file_to_write)
+      expect(version_file_to_write).to receive(:write).with(updated_contents)
+      Pkg::Util::Version.versionbump
+    end
+  end
+
+  describe '#base_pkg_version' do
+    version_hash = {
+      '5.6' => ['5.6', '1'],
+      '1.0.0' => ['1.0.0', '1'],
+      '2017.6.5.3' => ['2017.6.5.3', '1'],
+      '4.99.0-22' => ['4.99.0.22', '0.1'],
+      '1.0.0-658-gabc1234' => ['1.0.0.658.gabc1234', '0.1'],
+      '5.0.0.master.SNAPSHOT.2017.05.16T1357' => ['5.0.0.master', '0.1SNAPSHOT.2017.05.16T1357'],
+      '5.9.7-rc4' => ['5.9.7', '0.1rc4'],
+      '5.9.7-rc4-65-gabc1234' => ['5.9.7.65.gabc1234', '0.1rc4'],
+      '5.9.7-rc4-65-gabc1234-dirty' => ['5.9.7.65.gabc1234', '0.1rc4dirty'],
+      '4.99.0-dirty' => ['4.99.0', '0.1dirty'],
+      '4.99.0-56-gabc1234-dirty' => ['4.99.0.56.gabc1234', '0.1dirty']
+    }
+    version_hash.each do |pre, post|
+      before do
+        allow(Pkg::Config).to receive(:version) { pre }
+        allow(Pkg::Config).to receive(:release) { '1' }
+        allow(Pkg::Config).to receive(:vanagon_project) { false }
+      end
+
+      it "transforms #{pre} to #{post}" do
+        expect(Pkg::Util::Version.base_pkg_version(pre)).to eq post
+      end
+    end
+  end
+
+  describe '#final?' do
+    final_versions = [
+      '1.0.0',
+      '2017.6.5.3',
+      '0.6.8',
+      '2068.532.6',
+      '96.5'
+    ]
+
+    non_final_versions = [
+      '4.99.0-22',
+      '1.0.0-658-gabc1234',
+      '5.0.0.master.SNAPSHOT.2017.05.16T1357',
+      '5.9.7-rc4',
+      '4.99.0-56-dirty'
+    ]
+
+    final_versions.each do |version|
+      it "returns true when given #{version}" do
+        allow(Pkg::Config).to receive(:version) { nil }
+        expect(Pkg::Util::Version.final?(version)).to be true
+      end
+    end
+
+    non_final_versions.each do |version|
+      it "returns false when given #{version}" do
+        allow(Pkg::Config).to receive(:version) { nil }
+        expect(Pkg::Util::Version.final?(version)).to be false
+      end
+    end
+
+    it 'correctly reads a final version from Pkg::Config.version' do
+      allow(Pkg::Config).to receive(:version) { '1.0.0' }
+      expect(Pkg::Util::Version.final?).to be true
+    end
+
+    it 'correctly reads a non-final version from Pkg::Config.version' do
+      allow(Pkg::Config).to receive(:version) { '4.99.0-56-dirty' }
+      expect(Pkg::Util::Version.final?).to be false
+    end
+
+    it 'classifies dirty versions as final when allow_dirty_tree is set' do
+      allow(Pkg::Config).to receive(:allow_dirty_tree).and_return true
+      allow(Pkg::Config).to receive(:version) { '1.0.0-dirty' }
+      expect(Pkg::Util::Version.final?).to be true
+    end
+
+    it 'classifies dirty nonfinal versions as not final even when allow_dirty_tree is set' do
+      allow(Pkg::Config).to receive(:allow_dirty_tree).and_return true
+      allow(Pkg::Config).to receive(:version) { '1.0.0-22-dirty' }
+      expect(Pkg::Util::Version.final?).to be false
+    end
+  end
+
+  context "#dash_version" do
+    versions = {
+      '5.3.0' => '5.3.0',
+      '5.3.0-18-gfbddc8f' => '5.3.0-18',
+      '5.3.0-18-gfbddc8f-dirty' => '5.3.0-18-dirty',
+      '0.7.0-rc1' => '0.7.0-rc1',
+      '0.7.0-rc1-63-g51ccc51' => '0.7.0-rc1-63',
+      '0.7.0-rc1-63-g51ccc51-dirty'=> '0.7.0-rc1-63-dirty',
+    }
+    versions.each do |describe, reformatted|
+      it "correctly returns #{reformatted} when #{describe} is the git describe version" do
+        allow(Pkg::Util::Git).to receive(:ref_type).and_return 'sha'
+        allow(Pkg::Util::Git).to receive(:describe).and_return describe
+        expect(Pkg::Util::Version.dash_version).to eq reformatted
+      end
+    end
+  end
+end

data/spec/lib/packaging_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+#   We load packaging.rb once, in spec_helper, to avoid reloading the library
+#   and issuing warnings about already defined constants.
+describe "Pkg" do
+  it "should require the utilities module, Pkg::Util" do
+    Pkg::Util.should_not be_nil
+  end
+
+  it  "should require the configuration module, Pkg::Config" do
+    Pkg::Config.should_not be_nil
+  end
+
+  it  "should require the tar library, Pkg::Tar" do
+    Pkg::Tar.should_not be_nil
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rspec'
+require 'pathname'
+require 'rake'
+
+SPECDIR = Pathname(__FILE__).dirname
+PROJECT_ROOT = File.expand_path(File.join(Pathname(__FILE__).dirname, ".."))
+FIXTURES = File.join(SPECDIR, 'fixtures')
+
+require File.join(SPECDIR, '..', 'lib', 'packaging.rb')
+
+def load_task(name)
+  return false if (@loaded ||= {})[name]
+  load File.join(SPECDIR, '..', 'tasks', name)
+  @loaded[name] = true
+end
+
+def reset_env(keys)
+  keys.each do |key|
+    ENV[key] = nil
+  end
+end
+
+RSpec.configure do |config|
+  if Pkg::Util::OS.windows? && RUBY_VERSION =~ /^1\./
+    require 'win32console'
+    config.output_stream = $stdout
+    config.error_stream = $stderr
+
+    config.formatters.each do |f|
+      if not f.instance_variable_get(:@output).kind_of?(::File)
+        f.instance_variable_set(:@output, $stdout)
+      end
+    end
+  end
+end

data/static_artifacts/PackageInfo.plist

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<pkg-info followSymLinks="true" minimumSystemVersion="10.6" auth="root"/>
+

data/tasks/00_utils.rake

@@ -0,0 +1,216 @@
+#######################################################################
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                  !  DO NOT ADD TO THIS FILE  !                      #
+#                                                                     #
+#   Usage of this file to store utilities is deprecated. Any new      #
+#   utilities should be added to new or existing classes in           #
+#   lib/packaging/util. Any modified utilities should be migrated     #
+#   to new or existing classes in lib/packaging/util as well.         #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#                                                                     #
+#######################################################################
+
+
+
+
+
+# Utility methods used by the various rake tasks
+
+#######################################################################
+#                                                                     #
+#         DEPRECATED METHODS: Please move any newly depreacted        #
+#     methods into the following section so that we can easily        #
+#              see what methods are left to librarify.                #
+#                                                                     #
+#######################################################################
+
+def invoke_task(task, *args)
+  Pkg::Util.deprecate('invoke_task', 'Pkg::Util::RakeUtils.invoke_task')
+  Pkg::Util::RakeUtils.invoke_task(task, *args)
+end
+
+def rsync_to(*args)
+  Pkg::Util.deprecate('rsync_to', 'Pkg::Util::Net.rsync_to')
+  Pkg::Util::Net.rsync_to(args[0], args[1], args[2])
+end
+
+def rsync_from(*args)
+  Pkg::Util.deprecate('rsync_from', 'Pkg::Util::Net.rsync_from')
+  Pkg::Util::Net.rsync_from(args[0], args[1], args[2])
+end
+
+def mkdir_pr(*args)
+  Pkg::Util.deprecate('mkdir_pr', 'FileUtils.mkdir_p')
+  FileUtils.mkdir_p args
+end
+
+def ln(target, name)
+  Pkg::Util.deprecate('ln', 'FileUtils.ln')
+  FileUtils.ln(name, target, :force => true, :verbose => true)
+end
+
+def ln_sfT(src, dest)
+  Pkg::Util.deprecate('ln_sfT')
+  sh "ln -sfT #{src} #{dest}"
+end
+
+def git_commit_file(file, message = nil)
+  Pkg::Util.deprecate('git_commit_file', 'Pkg::Util::Git.git_commit_file')
+  Pkg::Util::Git.git_commit_file(file, message)
+end
+
+def git_bundle(treeish, appendix = nil, output_dir = nil)
+  Pkg::Util.deprecate('git_bundle', 'Pkg::Util::Git.git_bundle')
+  Pkg::Util::Git.git_bundle(treeish, appendix, output_dir)
+end
+
+def git_tag(version)
+  Pkg::Util.deprecate('git_tag', 'Pkg::Util::Git.git_tag')
+  Pkg::Util::Git.git_tag(version)
+end
+
+def git_pull(remote, branch)
+  Pkg::Util.deprecate('git_pull', 'Pkg::Util::Git.git_pull')
+  Pkg::Util::Git.git_pull(remote, branch)
+end
+
+def curl_form_data(uri, form_data = [], options = {})
+  Pkg::Util.deprecate("curl_form_data", "Pkg::Util::Net.curl_form_data")
+  Pkg::Util::Net.curl_form_data(uri, form_data, options)
+end
+
+def create_jenkins_job(name, xml_file)
+  Pkg::Util.deprecate("create_jenkins_job", "Pkg::Util::Jenkins.create_jenkins_job")
+  Pkg::Util::Jenkins.create_jenkins_job(name, xml_file)
+end
+
+def jenkins_job_exists?(name)
+  Pkg::Util.deprecate("jenkins_job_exists", "Pkg::Util::Jenkins.jenkins_job_exists?")
+  Pkg::Util::Jenkins.jenkins_job_exists?(name)
+end
+
+def print_url_info(url_string)
+  Pkg::Util.deprecate("print_url_info", "Pkg::Util::Net.print_url_info")
+  Pkg::Util::Net.print_url_info(url_string)
+end
+
+def retry_on_fail(args, &block)
+  Pkg::Util.deprecate("retry_on_fail", "Pkg::Util::Execution.retry_on_fail")
+  Pkg::Util::Execution.retry_on_fail(args, &block)
+end
+
+# ex combines the behavior of `%x{cmd}` and rake's `sh "cmd"`. `%x{cmd}` has
+# the benefit of returning the standard out of an executed command, enabling us
+# to query the file system, e.g. `contents = %x{ls}`. The drawback to `%x{cmd}`
+# is that on failure of a command (something returned non-zero) the return of
+# `%x{cmd}` is just an empty string. As such, we can't know if we succeeded.
+# Rake's `sh "cmd"`, on the other hand, will raise a RuntimeError if a command
+# does not return 0, but doesn't return any of the stdout from the command -
+# only true or false depending on its success or failure. With `ex(cmd)` we
+# purport to both return the results of the command execution (ala `%x{cmd}`)
+# while also raising an exception if a command does not succeed (ala `sh "cmd"`).
+def ex(command)
+  Pkg::Util.deprecate("ex", "Pkg::Util::Execution.ex")
+  Pkg::Util::Execution.ex(command)
+end
+
+def load_keychain
+  Pkg::Util.deprecate("load_keychain", "Pkg::Util::Gpg.load_keychain")
+  Pkg::Util::Gpg.load_keychain
+end
+
+def kill_keychain
+  Pkg::Util.deprecate("kill_keychain", "Pkg::Util::Gpg.kill_keychain")
+  Pkg::Util::Gpg.kill_keychain
+end
+
+def start_keychain
+  Pkg::Util.deprecate("start_keychain", "Pkg::Util::Gpg.start_keychain")
+  Pkg::Util::Gpg.start_keychain
+end
+
+def gpg_sign_file(file)
+  Pkg::Util.deprecate("gpg_sign_file", "Pkg::Util::Gpg.sign_file")
+  Pkg::Util::Gpg.sign_file(file)
+end
+
+def check_var(varname, var)
+  Pkg::Util.deprecate('check_var', 'Pkg::Util.check_var')
+  Pkg::Util.check_var(varname, var)
+end
+
+def rand_string
+  Pkg::Util.deprecate('invoke_task', 'Pkg::Util.rand_string')
+  Pkg::Util.rand_string
+end
+
+def escape_html(uri)
+  Pkg::Util.deprecate('escape_html', 'Pkg::Util::Net.escape_html')
+  Pkg::Util::Net.escape_html(uri)
+end
+
+def add_param_to_uri(uri, param)
+  Pkg::Util.deprecate('add_param_to_uri', 'Pkg::Util::Net.add_param_to_uri')
+  Pkg::Util::Net.add_param_to_uri(uri, param)
+end
+
+def cp_pr(src, dest, options = {})
+  Pkg::Util.deprecate('cp_pr', 'FileUtils.cp_r')
+  mandatory = { :preserve => true }
+  FileUtils.cp_r(src, dest, options.merge(mandatory))
+end
+
+def cp_p(src, dest, options = {})
+  Pkg::Util.deprecate('cp_p', 'FileUtils.cp')
+  mandatory = { :preserve => true }
+  FileUtils.cp(src, dest, options.merge(mandatory))
+end
+
+def remote_set_immutable(host, files)
+  Pkg::Util.deprecate('remote_set_immutable', 'Pkg::Util::Net.remote_set_immutable')
+  Pkg::Util::Net.remote_set_immutable(host, files)
+end
+
+def ask_yes_or_no
+  Pkg::Util.deprecate('ask_yes_or_no', 'Pkg::Util.ask_yes_or_no')
+  Pkg::Util.ask_yes_or_no
+end
+
+def confirm_ship(files)
+  Pkg::Util.deprecate('confirm_ship', 'Pkg::Util.confirm_ship')
+  Pkg::Util.confirm_ship(files)
+end
+
+def deprecate(old_cmd, new_cmd = nil)
+  Pkg::Util.deprecate('deprecate', 'Pkg::Util.deprecate')
+  Pkg::Util.deprecate(old_cmd, new_cmd)
+end
+
+def remote_bootstrap(host, treeish, tar_cmd = nil, tarball = nil)
+  Pkg::Util.deprecate('remote_bootstrap', 'Pkg::Util::Net.remote_bootstrap')
+  Pkg::Util::Net.remote_bootstrap(host, treeish, tar_cmd, tarball)
+end
+
+def remote_buildparams(host, build)
+  Pkg::Util.deprecate('remote_buildparams', 'Pkg::Util::Net.remote_buildparams')
+  Pkg::Util::Net.remote_buildparams(host, build)
+end
+
+def ship_gem(file)
+  Pkg::Util.deprecate('ship_gem', 'Pkg::Gem.ship')
+  Pkg::Gem.ship(file)
+end
+
+def set_cow_envs(cow)
+  Pkg::Util.deprecate('set_cow_envs', 'Pkg::Deb.set_cow_envs')
+  Pkg::Deb.set_cow_envs(cow)
+end

data/tasks/30_metrics.rake

@@ -0,0 +1,33 @@
+@metrics          = []
+def add_shipped_metrics(args)
+  @metrics << {
+    :type         => 'shipped',
+    :package      => (args[:package]             || Pkg::Config.project),
+    :version      => (args[:version]             || Pkg::Config.version),
+    :pe_version   => (args[:pe_version]          || Pkg::Config.pe_version),
+    :is_rc        => (args[:is_rc]               || false),
+  }
+end
+
+def post_shipped_metrics
+  require 'net/http'
+  @metrics.each do |metric|
+    type         = metric[:type]
+    package      = metric[:package]
+    version      = metric[:version]
+    pe_version   = metric[:pe_version]
+    is_rc        = metric[:is_rc]
+
+    uri = URI(Pkg::Config.metrics_url)
+    res = Net::HTTP.post_form(
+      uri,
+      {
+        'type'          => type,
+        'package'       => package,
+        'version'       => version,
+        'pe_version'    => pe_version,
+        'is_rc'         => is_rc,
+      }
+    )
+  end
+end

data/tasks/apple.rake

@@ -0,0 +1,266 @@
+# Title:        Rake task to build Apple packages for #{@project}.
+# Author:       Gary Larizza
+# Date:         05/18/2012
+# Description:  This task will create a DMG-encapsulated package that will
+#               install a package on OS X systems. This happens by building
+#               a directory tree of files that will then be fed to the
+#               packagemaker binary (can be installed by installing the
+#               XCode Tools) which will create the .pkg file.
+#
+
+# Path to Binaries (Constants)
+CP            = '/bin/cp'
+INSTALL       = '/usr/bin/install'
+DITTO         = '/usr/bin/ditto'
+PKGBUILD      = '/usr/bin/pkgbuild'
+
+# Setup task to populate all the variables
+task :setup do
+  # Read the Apple file-mappings
+  begin
+    @source_files        = Pkg::Util::Serialization.load_yaml('ext/osx/file_mapping.yaml')
+  rescue => e
+    fail "Could not load Apple file mappings from 'ext/osx/file_mapping.yaml'\n#{e}"
+  end
+  @package_name          = Pkg::Config.project
+  @title                 = "#{Pkg::Config.project}-#{Pkg::Config.version}"
+  @reverse_domain        = "com.#{Pkg::Config.packager}.#{@package_name}"
+  @package_major_version = Pkg::Config.version.split('.')[0]
+  @package_minor_version = Pkg::Config.version.split('.')[1] +
+                           Pkg::Config.version.split('.')[2].split('-')[0].split('rc')[0]
+  @pm_restart            = 'None'
+  @build_date            = Time.new.strftime("%Y-%m-%dT%H:%M:%SZ")
+  @apple_bindir          = File.join('/', @source_files['directories']['bin']['path'])
+  @apple_sbindir         = '/usr/sbin'
+  @apple_libdir          = File.join('/', @source_files['directories']['lib']['path'])
+  @apple_old_libdir      = '/usr/lib/ruby/site_ruby/1.8'
+  @apple_docdir          = '/usr/share/doc'
+end
+
+# method:       make_directory_tree
+# description:  This method sets up the directory structure that packagemaker
+#               needs to build a package. A prototype.plist file (holding
+#               package-specific options) is built from an ERB template located
+#               in the ext/osx directory.
+def make_directory_tree
+  project_tmp    = "#{Pkg::Util::File.mktemp}/#{@package_name}"
+  @scratch       = "#{project_tmp}/#{@title}"
+  @working_tree  = {
+     'scripts'   => "#{@scratch}/scripts",
+     'resources' => "#{@scratch}/resources",
+     'working'   => "#{@scratch}/root",
+     'payload'   => "#{@scratch}/payload",
+  }
+  puts "Cleaning Tree: #{project_tmp}"
+  rm_rf(project_tmp)
+  @working_tree.each do |key, val|
+    mkdir_p(val)
+  end
+
+  if File.exists?('ext/osx/postflight.erb')
+    Pkg::Util::File.erb_file 'ext/osx/postflight.erb', "#{@working_tree["scripts"]}/postinstall", false, :binding => binding
+  end
+
+  if File.exists?('ext/osx/preflight.erb')
+    Pkg::Util::File.erb_file 'ext/osx/preflight.erb', "#{@working_tree["scripts"]}/preinstall", false, :binding => binding
+  end
+
+  if File.exists?('ext/osx/prototype.plist.erb')
+    Pkg::Util::File.erb_file 'ext/osx/prototype.plist.erb', "#{@scratch}/prototype.plist", false, :binding => binding
+  end
+
+  if File.exists?('ext/packaging/static_artifacts/PackageInfo.plist')
+    cp 'ext/packaging/static_artifacts/PackageInfo.plist', "#{@scratch}/PackageInfo.plist"
+  end
+
+end
+
+# method:        build_dmg
+# description:   This method builds a package from the directory structure in
+#                /tmp/#{@project} and puts it in the
+#                /tmp/#{@project}/#{@project}-#{version}/payload directory. A DMG is
+#                created, using hdiutil, based on the contents of the
+#                /tmp/#{@project}/#{@project}-#{version}/payload directory. The resultant
+#                DMG is placed in the pkg/apple directory.
+#
+def build_dmg
+  # Local Variables
+  dmg_format_code   = 'UDZO'
+  zlib_level        = '9'
+  dmg_format_option = "-imagekey zlib-level=#{zlib_level}"
+  dmg_format        = "#{dmg_format_code} #{dmg_format_option}"
+  dmg_file          = "#{@title}.dmg"
+  package_file      = "#{@title}.pkg"
+
+  # Build .pkg file
+  system("sudo #{PKGBUILD} --root #{@working_tree['working']} \
+    --scripts #{@working_tree['scripts']} \
+    --identifier #{@reverse_domain} \
+    --version #{Pkg::Config.version} \
+    --install-location / \
+    --ownership preserve \
+    --info #{@scratch}/PackageInfo.plist \
+    #{@working_tree['payload']}/#{package_file}")
+
+  # Build .dmg file
+  system("sudo hdiutil create -volname #{@title} \
+    -srcfolder #{@working_tree['payload']} \
+    -uid 99 \
+    -gid 99 \
+    -ov \
+    -format #{dmg_format} \
+    #{dmg_file}")
+
+  if File.directory?("#{pwd}/pkg/apple")
+    sh "sudo mv #{pwd}/#{dmg_file} #{pwd}/pkg/apple/#{dmg_file}"
+    puts "moved:   #{dmg_file} has been moved to #{pwd}/pkg/apple/#{dmg_file}"
+  else
+    mkdir_p("#{pwd}/pkg/apple")
+    sh "sudo mv #{pwd}/#{dmg_file} #{pwd}/pkg/apple/#{dmg_file}"
+    puts "moved:   #{dmg_file} has been moved to #{pwd}/pkg/apple/#{dmg_file}"
+  end
+end
+
+# method:        pack_source
+# description:   This method copies the #{@project} source into a directory
+#                structure in /tmp/#{@project}/#{@project}-#{version}/root mirroring the
+#                structure on the target system for which the package will be
+#                installed. Anything installed into /tmp/#{@project}/root will be
+#                installed as the package's payload.
+#
+def pack_source
+  work          = "#{@working_tree['working']}"
+  source = pwd
+
+  # Make all necessary directories
+  @source_files.each_value do |files|
+    files.each_value do |params|
+      mkdir_p "#{work}/#{params['path']}"
+    end
+  end
+
+  # Install directory contents into place
+  unless @source_files['directories'].nil?
+    @source_files['directories'].each do |dir, params|
+      unless FileList["#{source}/#{dir}/*"].empty?
+        cmd = "#{DITTO} #{source}/#{dir}/ #{work}/#{params['path']}"
+        puts cmd
+        system(cmd)
+      end
+    end
+  end
+
+  # Setup a preinstall script and replace variables in the files with
+  # the correct paths.
+  if File.exists?("#{@working_tree['scripts']}/preinstall")
+    chmod(0755, "#{@working_tree['scripts']}/preinstall")
+    sh "sudo chown root:wheel #{@working_tree['scripts']}/preinstall"
+  end
+
+  # Setup a postinstall from from the erb created earlier
+  if File.exists?("#{@working_tree['scripts']}/postinstall")
+    chmod(0755, "#{@working_tree['scripts']}/postinstall")
+    sh "sudo chown root:wheel #{@working_tree['scripts']}/postinstall"
+  end
+
+  # Do a run through first setting the specified permissions then
+  # making sure 755 is set for all directories
+  unless @source_files['directories'].nil?
+    @source_files['directories'].each do |dir, params|
+      owner = params['owner']
+      group = params['group']
+      perms = params['perms']
+      path  = params['path']
+      ##
+      # Before setting our default permissions for all subdirectories/files of
+      # each directory listed in directories, we have to get a list of the
+      # directories. Otherwise, when we set the default perms (most likely
+      # 0644) we'll lose traversal on subdirectories, and later when we want to
+      # ensure they're 755 we won't be able to find them.
+      #
+      directories = []
+      Dir["#{work}/#{path}/**/*"].each do |file|
+        directories << file if File.directory?(file)
+      end
+
+      ##
+      # Here we're setting the default permissions for all files as described
+      # in file_mapping.yaml. Since we have a listing of directories, it
+      # doesn't matter if we remove executable permission on directories, we'll
+      # reset it later.
+      #
+      sh "sudo chmod -R #{perms} #{work}/#{path}"
+
+      ##
+      # We know at least one directory, the one listed in file_mapping.yaml, so
+      # we set it executable.
+      #
+      sh "sudo chmod 0755 #{work}/#{path}"
+
+      ##
+      # Now that default perms are set, we go in and reset executable perms on
+      # directories
+      #
+      directories.each { |d| sh "sudo chmod 0755 #{d}" }
+
+      ##
+      # Finally we set the owner/group as described in file_mapping.yaml
+      #
+      sh "sudo chown -R #{owner}:#{group} #{work}/#{path}"
+    end
+  end
+
+  # Install any files
+  unless @source_files['files'].nil?
+    @source_files['files'].each do |file, params|
+      owner = params['owner']
+      group = params['group']
+      perms = params['perms']
+      dest  = params['path']
+      # Allow for regexs like [A-Z]*
+      FileList[file].each do |f|
+        cmd = "sudo #{INSTALL} -o #{owner} -g #{group} -m #{perms} #{source}/#{f} #{work}/#{dest}"
+        puts cmd
+        system(cmd)
+      end
+    end
+  end
+
+  # Hackery here. Our packages were using /usr/bin/env ruby and installing to
+  # system ruby loadpath, which breaks horribly in a multi-ruby (rbenv, etc)
+  # environment. This goes into the workdir and looks for any files dropped in
+  # bin, and "seds" the shebang to /usr/bin/ruby. I would love to be using a
+  # ruby approach to this instead of shelling out to sed, but the problem is
+  # we've already set ownership on these files, almost exclusively to root, and
+  # thus we need to sudo out.
+  if @source_files['directories'] and @source_files['directories']['bin']
+    if bindir = @source_files['directories']['bin']['path']
+      Dir[File.join(work, bindir, '*')].each do |binfile|
+        sh "sudo /usr/bin/sed -E -i '' '1 s,^#![[:space:]]*/usr/bin/env[[:space:]]+ruby$,#!/usr/bin/ruby,' #{binfile}"
+      end
+    end
+  end
+end
+
+namespace :package do
+  desc "Task for building an Apple Package"
+  task :apple => [:setup] do
+    if Pkg::Config.build_dmg
+      bench = Benchmark.realtime do
+        # Test for pkgbuild binary
+        fail "pkgbuild must be installed." unless \
+          File.exists?(PKGBUILD)
+
+        make_directory_tree
+        pack_source
+        build_dmg
+      end
+      puts "Finished building in: #{bench}"
+    end
+  end
+end
+
+# An alias task to simplify our remote logic in jenkins.rake
+namespace :pl do
+  task :dmg => "package:apple"
+end