omnibus 3.1.1 → 3.2.0.rc.1

data/lib/omnibus/packagers/mac_dmg.rb

@@ -155,13 +155,13 @@ module Omnibus
                set current view of container window to icon view
                set toolbar visible of container window to false
                set statusbar visible of container window to false
-               set the bounds of container window to {#{project.config[:dmg_window_bounds]}}
+               set the bounds of container window to {#{Config[:dmg_window_bounds]}}
                set theViewOptions to the icon view options of container window
                set arrangement of theViewOptions to not arranged
                set icon size of theViewOptions to 72
                set background picture of theViewOptions to file ".support:'background.png'"
                delay 5
-               set position of item "'#{project.name}.pkg'" of container window to {#{project.config[:dmg_pkg_position]}}
+               set position of item "'#{project.name}.pkg'" of container window to {#{Config[:dmg_pkg_position]}}
                update without registering applications
                delay 5
              end tell
@@ -208,7 +208,7 @@ module Omnibus
 
     # @see Base#package_name
     def package_name
-      "#{name}-#{version}-#{iteration}.dmg"
+      "#{project.name}-#{project.build_version}-#{project.iteration}.dmg"
     end
 
     # The path to the folder that we should stage.
@@ -222,14 +222,14 @@ module Omnibus
     #
     # @return [String]
     def writable_dmg
-      File.expand_path("#{staging_dir}/#{name}-writable.dmg")
+      File.expand_path("#{staging_dir}/#{project.name}-writable.dmg")
     end
 
     # The path where the final dmg will be produced.
     #
     # @return [String]
     def final_dmg
-      File.expand_path("#{project.package_dir}/#{name}-#{version}-#{iteration}.dmg")
+      File.expand_path("#{Config.package_dir}/#{project.name}-#{project.build_version}-#{project.iteration}.dmg")
     end
   end
 end

data/lib/omnibus/packagers/mac_pkg.rb

@@ -33,7 +33,7 @@ module Omnibus
 
     setup do
       purge_directory(staging_dir)
-      purge_directory(project.package_dir)
+      purge_directory(Config.package_dir)
       purge_directory(staging_resources_path)
       copy_directory(resources_path, staging_resources_path)
 
@@ -49,7 +49,7 @@ module Omnibus
       generate_distribution
       build_product_pkg
 
-      if project.config[:build_dmg]
+      if Config.build_dmg
         Packager::MacDmg.new(self).run!
       end
     end
@@ -60,14 +60,14 @@ module Omnibus
 
     # @see Base#package_name
     def package_name
-      "#{name}-#{version}-#{iteration}.pkg"
+      "#{project.name}-#{project.build_version}-#{project.iteration}.pkg"
     end
 
     # The full path where the product package was/will be written.
     #
     # @return [String] Path to the packge file.
     def final_pkg
-      File.expand_path("#{project.package_dir}/#{package_name}")
+      File.expand_path("#{Config.package_dir}/#{package_name}")
     end
 
     #
@@ -79,10 +79,10 @@ module Omnibus
       execute <<-EOH.gsub(/^ {8}/, '')
         pkgbuild \\
           --identifier "#{identifier}" \\
-          --version "#{version}" \\
-          --scripts "#{scripts}" \\
-          --root "#{install_path}" \\
-          --install-location "#{install_path}" \\
+          --version "#{project.build_version}" \\
+          --scripts "#{project.package_scripts_path}" \\
+          --root "#{project.install_dir}" \\
+          --install-location "#{project.install_dir}" \\
           "#{component_pkg}"
       EOH
     end
@@ -100,7 +100,7 @@ module Omnibus
         file.puts <<-EOH.gsub(/^ {10}/, '')
           <?xml version="1.0" standalone="no"?>
           <installer-gui-script minSpecVersion="1">
-              <title>#{friendly_name}</title>
+              <title>#{project.friendly_name}</title>
               <background file="background.png" alignment="bottomleft" mime-type="image/png"/>
               <welcome file="welcome.html" mime-type="text/html"/>
               <license file="license.html" mime-type="text/html"/>
@@ -117,7 +117,7 @@ module Omnibus
               <choice id="#{identifier}" visible="false">
                   <pkg-ref id="#{identifier}"/>
               </choice>
-              <pkg-ref id="#{identifier}" version="#{version}" onConclusion="none">#{component_pkg}</pkg-ref>
+              <pkg-ref id="#{identifier}" version="#{project.build_version}" onConclusion="none">#{component_pkg}</pkg-ref>
           </installer-gui-script>
         EOH
       end
@@ -128,16 +128,17 @@ module Omnibus
     # product that is shipped to end users.
     #
     def build_product_pkg
-      build_command = [
-        'productbuild',
-        %Q(--distribution "#{distribution_file}"),
-        %Q(--resources "#{staging_resources_path}"),
-      ]
+      command = <<-EOH.gsub(/^ {8}/, '')
+        productbuild \\
+          --distribution "#{distribution_file}" \\
+          --resources "#{staging_resources_path}" \\
+      EOH
 
-      build_command << %Q(--sign "#{project.config[:signing_identity]}") if project.config[:sign_pkg]
-      build_command << final_pkg
+      command << %Q(  --sign "#{Config.signing_identity}" \\\n) if Config.sign_pkg
+      command << %Q(  "#{final_pkg}")
+      command << %Q(\n)
 
-      execute build_command.join(' ')
+      execute(command)
     end
 
     # The identifier for this mac package (the com.whatever.thing.whatever).
@@ -161,7 +162,7 @@ module Omnibus
     #
     # @return [String] the filename of the component .pkg file to create.
     def component_pkg
-      "#{name}-core.pkg"
+      "#{project.name}-core.pkg"
     end
 
     # Sanitize the given string for the package identifier.

data/lib/omnibus/packagers/windows_msi.rb

@@ -32,7 +32,7 @@ module Omnibus
 
     setup do
       purge_directory(staging_dir)
-      purge_directory(project.package_dir)
+      purge_directory(Config.package_dir)
       purge_directory(staging_resources_path)
       copy_directory(resources_path, staging_resources_path)
 
@@ -49,7 +49,7 @@ module Omnibus
       # harvest the files with heat.exe
       # recursively generate fragment for project directory
       execute [
-        "heat.exe dir \"#{install_path}\"",
+        "heat.exe dir \"#{project.install_dir}\"",
         '-nologo -srd -gg -cg ProjectDir',
         '-dr PROJECTLOCATION -var var.ProjectSourceDir',
         '-out project-files.wxs',
@@ -58,7 +58,7 @@ module Omnibus
       # compile with candle.exe
       execute [
         'candle.exe -nologo',
-        "-dProjectSourceDir=\"#{install_path}\" project-files.wxs",
+        "-dProjectSourceDir=\"#{project.install_dir}\" project-files.wxs",
         "\"#{resource('source.wxs')}\"",
       ].join(' ')
 
@@ -78,14 +78,14 @@ module Omnibus
 
     # @see Base#package_name
     def package_name
-      "#{name}-#{version}-#{iteration}.msi"
+      "#{project.name}-#{project.build_version}-#{project.iteration}.msi"
     end
 
     # The full path where the product package was/will be written.
     #
     # @return [String] Path to the packge file.
     def final_pkg
-      File.expand_path("#{project.package_dir}/#{package_name}")
+      File.expand_path("#{Config.package_dir}/#{package_name}")
     end
 
     # Helper method to set the msi version for a given project
@@ -101,8 +101,8 @@ module Omnibus
       # MSI source files expect two versions to be set in the msi_parameters:
       # msi_version & msi_display_version
 
-      versions = version.split(/[.+-]/)
-      @msi_version = "#{versions[0]}.#{versions[1]}.#{versions[2]}.#{@project.build_iteration}"
+      versions = project.build_version.split(/[.+-]/)
+      @msi_version = "#{versions[0]}.#{versions[1]}.#{versions[2]}.#{project.build_iteration}"
       @msi_display_version = "#{versions[0]}.#{versions[1]}.#{versions[2]}"
     end
   end

data/lib/omnibus/project.rb

@@ -19,549 +19,514 @@ require 'time'
 require 'json'
 
 module Omnibus
+  #
   # Omnibus project DSL reader
   #
-  # @todo It seems like there's a bit of a conflation between a
-  #   "project" and a "package" in this class... perhaps the
-  #   package-building portions should be extracted to a separate
-  #   class.
-  # @todo: Reorder DSL methods to fit in the same YARD group
-  # @todo: Generate the DSL methods via metaprogramming... they're all so similar
+  # @todo It seems like there's a bit of a conflation between a "project" and a
+  #   "package" in this class... perhaps the package-building portions should be
+  #   extracted to a separate class.
+  #
+  #
   class Project
+    class << self
+      #
+      # @param [String] filepath
+      #   the path to the project definition to load from disk
+      #
+      # @return [Software]
+      #
+      def load(filepath)
+        instance = new(filepath)
+        instance.evaluate_file(filepath)
+        instance
+      end
+    end
+
+    include Cleanroom
+    include Digestable
     include Logging
+    include NullArgumentable
+    include Sugarable
     include Util
 
-    NULL_ARG = Object.new
-
-    attr_reader :library
-    attr_accessor :dirty_cache
-    attr_accessor :build_version_dsl
-    attr_reader :resources_path
-
-    # Convenience method to initialize a Project from a DSL file.
-    #
-    # @param filename [String] the filename of the Project DSL file to load.
-    def self.load(filename)
-      new(IO.read(filename), filename)
+    def initialize(filepath = nil)
+      @filepath = filepath
     end
 
-    # Create a new Project from the contents of a DSL file.  Prefer
-    # calling {Omnibus::Project#load} instead of using this method
-    # directly.
     #
-    # @param io [String] the contents of a Project DSL (_not_ the filename!)
-    # @param filename [String] unused!
+    # @!group DSL methods
     #
-    # @see Omnibus::Project#load
-    def initialize(io, filename)
-      @output_package = nil
-      @name = nil
-      @friendly_name = nil
-      @msi_parameters = {}
-      @package_name = nil
-      @install_path = nil
-      @resources_path = nil
-      @homepage = nil
-      @description = nil
-      @replaces = nil
-      @mac_pkg_identifier = nil
-      @overrides = {}
-
-      @exclusions = []
-      @conflicts = []
-      @config_files = []
-      @extra_package_files = []
-      @dependencies = []
-      @runtime_dependencies = []
-      @dirty_cache = false
-      instance_eval(io, filename)
-      validate
-
-      @library = Omnibus::Library.new(self)
-    end
-
-    def <=>(other)
-      self.name <=> other.name
-    end
-
-    def build_me
-      FileUtils.mkdir_p(config.package_dir)
-      FileUtils.mkdir_p('pkg')
-      FileUtils.rm_rf(install_path)
-      FileUtils.mkdir_p(install_path)
-
-      library.build_order.each do |software|
-        software.build_me
-      end
-      health_check_me
-      package_me
-    end
-
-    def health_check_me
-      if Ohai.platform == 'windows'
-        log.info(log_key) { 'Skipping health check on Windows' }
-      else
-        # build a list of all whitelist files from all project dependencies
-        whitelist_files = library.components.map { |component| component.whitelist_files }.flatten
-        Omnibus::HealthCheck.run(install_path, whitelist_files)
-      end
-    end
-
-    def package_me
-      package_types.each do |pkg_type|
-        if pkg_type == 'makeself'
-          run_makeself
-        elsif pkg_type == 'msi'
-          run_msi
-        elsif pkg_type == 'bff'
-          run_bff
-        elsif pkg_type == 'pkgmk'
-          run_pkgmk
-        elsif pkg_type == 'mac_pkg'
-          run_mac_package_build
-        elsif pkg_type == 'mac_dmg'
-          # noop, since the dmg creation is handled by the packager
-        else # pkg_type == "fpm"
-          run_fpm(pkg_type)
-        end
-
-        render_metadata(pkg_type)
+    # The following DSL methods are available from within the project
+    # definitions.
+    # --------------------------------------------------
 
-        if Ohai.platform == 'windows'
-          cp_cmd = "xcopy #{config.package_dir}\\*.msi pkg\\ /Y"
-        elsif Ohai.platform == 'aix'
-          cp_cmd = "cp #{config.package_dir}/*.bff pkg/"
-        else
-          cp_cmd = "cp #{config.package_dir}/* pkg/"
-        end
-
-        shellout!(cp_cmd)
-      end
-    end
-
-    # Ensures that certain project information has been set
     #
-    # @todo raise MissingProjectConfiguration instead of printing the warning
-    #   in the next major release
+    # **[Required]** Set or retrieve the name of the project.
     #
-    # @return [void]
-    def validate
-      name && install_path && maintainer && homepage
-      if package_name == replaces
-        log.warn { BadReplacesLine.new.message }
-      end
-    end
-
-    # @!group DSL methods
-    # Here is some broad documentation for the DSL methods as a whole.
-
-    # Set or retrieve the name of the project
+    # @example
+    #   name 'chef'
+    #
+    # @raise [MissingProjectConfiguration] if a value was not set before being
+    #   subsequently retrieved
+    #
+    # @param [String] val
+    #   the name to set
     #
-    # @param val [String] the name to set
     # @return [String]
     #
-    # @raise [MissingProjectConfiguration] if a value was not set
-    #   before being subsequently retrieved (i.e., a name
-    #   must be set in order to build a project)
-    def name(val = NULL_ARG)
-      @name = val unless val.equal?(NULL_ARG)
-      @name || raise(MissingProjectConfiguration.new('name', 'my_project'))
+    def name(val = NULL)
+      if null?(val)
+        @name || raise(MissingProjectConfiguration.new('name', 'my_project'))
+      else
+        @name = val
+      end
     end
+    expose :name
 
-    # Set or retrieve a friendly name for the project
     #
-    # @param val [String] the name to set
+    # Set or retrieve a friendly name for the project. This defaults to the
+    # capitalized name if not specified.
+    #
+    # @example
+    #   friendly_name 'Chef'
+    #
+    # @param [String] val
+    #   the name to set
+    #
     # @return [String]
     #
-    def friendly_name(val = NULL_ARG)
-      @friendly_name = val unless val.equal?(NULL_ARG)
-      @friendly_name || @name.capitalize
+    def friendly_name(val = NULL)
+      if null?(val)
+        @friendly_name || name.capitalize
+      else
+        @friendly_name = val
+      end
     end
+    expose :friendly_name
 
+    #
     # Set or retrieve the custom msi building parameters
     #
-    # @param val [Hash] the name to set
-    # @param block [Proc] block to run when building the msi that returns a hash
+    # @example Using a hash
+    #   msi_parameters upgrade_code: 'ABCD-1234'
+    #
+    # @example Using a block
+    #   msi_parameters do
+    #     # some complex operation
+    #     { key: value }
+    #   end
+    #
+    # @param [Hash] val
+    #   the parameters to set
+    # @param [Proc] block
+    #   block to run when building the msi that returns a hash
+    #
     # @return [Hash]
     #
-    def msi_parameters(val = NULL_ARG, &block)
-      if block_given?
-        unless val.equal?(NULL_ARG)
-          raise 'can not specify additional parameters when block is given'
-        end
+    def msi_parameters(val = NULL, &block)
+      if block && !null?(val)
+        raise Error, 'You cannot specify additional parameters to ' \
+          '#msi_parameters when a block is given!'
+      end
 
+      if block
         @msi_parameters = block
       else
-        if !val.equal?(NULL_ARG)
-          @msi_parameters = val
-        else
-          # Return the value of msi_parameters
-          if @msi_parameters.is_a? Proc
+        if null?(val)
+          if @msi_parameters.is_a?(Proc)
             @msi_parameters.call
           else
-            @msi_parameters
+            @msi_parameters ||= {}
           end
+        else
+          @msi_parameters = val
         end
       end
     end
+    expose :msi_parameters
 
-    # Set or retrieve the package name of the project.  Unless
-    # explicitly set, the package name defaults to the project name
     #
-    # @param val [String] the package name to set
+    # Set or retrieve the package name of the project. Defaults to the package
+    # name defaults to the project name.
+    #
+    # @example
+    #   package_name 'com.chef.project'
+    #
+    # @param [String] val
+    #   the package name to set
+    #
     # @return [String]
-    def package_name(val = NULL_ARG)
-      @package_name = val unless val.equal?(NULL_ARG)
-      @package_name.nil? ? @name : @package_name
+    #
+    def package_name(val = NULL)
+      if null?(val)
+        @package_name || name
+      else
+        @package_name = val
+      end
     end
+    expose :package_name
 
-    # Set or retrieve the path at which the project should be
+    #
+    # **[Required]** Set or retrieve the path at which the project should be
     # installed by the generated package.
     #
-    # @param val [String]
+    # @example
+    #   install_dir '/opt/chef'
+    #
+    # @raise [MissingProjectConfiguration] if a value was not set before being
+    #   subsequently retrieved
+    #
+    # @param [String] val
+    #   the install path to set
+    #
     # @return [String]
     #
-    # @raise [MissingProjectConfiguration] if a value was not set
-    #   before being subsequently retrieved (i.e., an install_path
-    #   must be set in order to build a project)
-    def install_path(val = NULL_ARG)
-      unless val.equal?(NULL_ARG)
-        @install_path = windows_safe_path(val)
+    def install_dir(val = NULL)
+      if null?(val)
+        @install_dir || raise(MissingProjectConfiguration.new('install_dir', '/opt/chef'))
+      else
+        @install_dir = windows_safe_path(val)
+      end
+    end
+    expose :install_dir
+
+    #
+    # @deprecated Use {#install_dir} instead.
+    #
+    # @example (see #install_dir)
+    # @raise (see #install_dir)
+    # @param (see #install_dir)
+    # @return (see #install_dir)
+    #
+    def install_path(val = NULL)
+      log.deprecated(log_key) do
+        "install_path (DSL). Please use install_dir instead."
       end
-      @install_path || raise(MissingProjectConfiguration.new('install_path', '/opt/chef'))
+
+      install_dir(val)
     end
+    expose :install_path
 
-    # Set or retrieve the the package maintainer.
     #
-    # @param val [String]
+    # Path to the +/files+ directory in the omnibus project. This directory can
+    # contain assets used for creating packages (e.g., Mac .pkg files and
+    # Windows MSIs can be installed by GUI which can optionally be customized
+    # with background images, license agreements, etc.)
+    #
+    # This method delegates to the {Config.project_root} module function so that
+    # Packagers classes rely only on the Project object for their inputs.
+    #
+    # @example
+    #   patch = File.join(files_path, 'rubygems', 'patch.rb')
+    #
     # @return [String]
+    #   path to the files directory
     #
-    # @raise [MissingProjectConfiguration] if a value was not set
-    #   before being subsequently retrieved (i.e., a maintainer must
-    #   be set in order to build a project)
-    def maintainer(val = NULL_ARG)
-      @maintainer = val unless val.equal?(NULL_ARG)
-      @maintainer || raise(MissingProjectConfiguration.new('maintainer', 'Chef Software, Inc.'))
+    def files_path
+      "#{Config.project_root}/files"
     end
+    expose :files_path
 
-    # Set or retrive the package homepage.
     #
-    # @param val [String]
+    # **[Required]** Set or retrieve the the package maintainer.
+    #
+    # @example
+    #   maintainer 'Chef Software, Inc.'
+    #
+    # @raise [MissingProjectConfiguration] if a value was not set before being
+    #   subsequently retrieved
+    #
+    # @param [String] val
+    #   the name of the maintainer
+    #
     # @return [String]
     #
-    # @raise [MissingProjectConfiguration] if a value was not set
-    #   before being subsequently retrieved (i.e., a homepage must be
-    #   set in order to build a project)
-    def homepage(val = NULL_ARG)
-      @homepage = val unless val.equal?(NULL_ARG)
-      @homepage || raise(MissingProjectConfiguration.new('homepage', 'http://www.getchef.com'))
+    def maintainer(val = NULL)
+      if null?(val)
+        @maintainer || raise(MissingProjectConfiguration.new('maintainer', 'Chef Software, Inc.'))
+      else
+        @maintainer = val
+      end
     end
+    expose :maintainer
 
-    # Defines the iteration for the package to be generated.  Adheres
-    # to the conventions of the platform for which the package is
-    # being built.
     #
-    # All iteration strings begin with the value set in {#build_iteration}
+    # **[Required]** Set or retrive the package homepage.
+    #
+    # @example
+    #   homepage 'https://www.getchef.com'
+    #
+    # @raise [MissingProjectConfiguration] if a value was not set before being
+    #   subsequently retrieved
+    #
+    # @param [String] val
+    #   the homepage for the project
     #
     # @return [String]
-    def iteration
-      case platform_family
-      when 'rhel'
-        platform_version =~ /^(\d+)/
-        maj = Regexp.last_match[1]
-        "#{build_iteration}.el#{maj}"
-      when 'freebsd'
-        platform_version =~ /^(\d+)/
-        maj = Regexp.last_match[1]
-        "#{build_iteration}.#{platform}.#{maj}.#{machine}"
-      when 'windows'
-        "#{build_iteration}.windows"
-      when 'aix', 'debian', 'mac_os_x'
-        "#{build_iteration}"
+    #
+    def homepage(val = NULL)
+      if null?(val)
+        @homepage || raise(MissingProjectConfiguration.new('homepage', 'http://www.getchef.com'))
       else
-        "#{build_iteration}.#{platform}.#{platform_version}"
+        @homepage = val
       end
     end
+    expose :homepage
 
-    # Set or retrieve the project description.  Defaults to `"The full
-    # stack of #{name}"`
     #
-    # Corresponds to the `--description` flag of
+    # Set or retrieve the project description.
+    #
+    # @example
+    #   description 'This is my description'
+    #
+    # Corresponds to the +--description+ flag of
     # {https://github.com/jordansissel/fpm fpm}.
     #
-    # @param val [String] the project description
+    # @param [String] val
+    #   the project description
+    #
     # @return [String]
     #
-    # @see #name
-    def description(val = NULL_ARG)
-      @description = val unless val.equal?(NULL_ARG)
-      @description || "The full stack of #{name}"
+    def description(val = NULL)
+      if null?(val)
+        @description ||= "The full stack of #{name}"
+      else
+        @description = val
+      end
     end
+    expose :description
 
+    #
     # Set or retrieve the name of the package this package will replace.
     #
-    # Ultimately used as the value for the `--replaces` flag in
+    # Ultimately used as the value for the +--replaces+ flag in
     # {https://github.com/jordansissel/fpm fpm}.
     #
     # This should only be used when renaming a package and obsoleting the old
-    # name of the package.  Setting this to the same name as package_name will
+    # name of the package. Setting this to the same name as package_name will
     # cause RPM upgrades to fail.
     #
-    # @param val [String] the name of the package to replace
+    # @example
+    #   replace 'the-old-package'
+    #
+    # @param [String] val
+    #   the name of the package to replace
+    #
     # @return [String]
-    def replaces(val = NULL_ARG)
-      @replaces = val unless val.equal?(NULL_ARG)
-      @replaces
+    #
+    def replaces(val = NULL)
+      if null?(val)
+        @replaces
+      else
+        @replaces = val
+      end
     end
+    expose :replaces
 
+    #
     # Add to the list of packages this one conflicts with.
     #
-    # Specifying conflicts is optional.  See the `--conflicts` flag in
+    # Specifying conflicts is optional.  See the +--conflicts+ flag in
     # {https://github.com/jordansissel/fpm fpm}.
     #
-    # @param val [String]
-    # @return [void]
+    # @example
+    #   conflicts 'foo'
+    #   conflicts 'bar'
+    #
+    # @param [String] val
+    #   the conflict to add
+    #
+    # @return [Array<String>]
+    #   the list of conflicts
+    #
     def conflict(val)
-      @conflicts << val
+      conflicts << val
+      conflicts.dup
     end
+    expose :conflict
 
+    #
     # Set or retrieve the version of the project.
     #
-    # Options that can be used when constructing a build_version:
+    # @example Using a string
+    #   build_version '1.0.0'
     #
-    # 1. Use a string as version
-    #   build_version "1.0.0"
-    # 2. Get the build_version from git of the omnibus repo
-    #   build version do
+    # @example From git
+    #   build_version do
     #     source :git
     #   end
-    # 3. Get the build_version from git of a dependency
-    #   build version do
-    #     source :git, from_dependency: "chef"
+    #
+    # @example From the version of a dependency
+    #   build_version do
+    #     source :version, from_dependency: 'chef'
     #   end
-    # 4. Set the build_version to the version of a dependency
-    #   build version do
-    #     source :version, from_dependency: "chef"
+    #
+    # @example From git of a dependency
+    #   build_version do
+    #     source :git, from_dependency: 'chef'
     #   end
     #
-    # When using :git source, by default the output format of the build_version
-    # is semver. This can be modified using the :output_format parameter to any
-    # of the methods of Omnibus::BuildVersion. E.g.:
+    # When using the +:git+ source, by default the output format of the
+    # +build_version+ is semver. This can be modified using the +:output_format+
+    # parameter to any of the methods of +BuildVersion+. For example:
+    #
     #   build version do
-    #     source :git, from_dependency: "chef"
+    #     source :git, from_dependency: 'chef'
     #     output_format :git_describe
     #   end
     #
-    # @param val [String] the version to set
-    # @param block [Proc] block to run when constructing the build_version
-    # @return [String]
-    #
     # @see Omnibus::BuildVersion
     # @see Omnibus::BuildVersionDSL
-    def build_version(val = NULL_ARG, &block)
-      if block_given?
-        @build_version_dsl =  BuildVersionDSL.new(&block)
+    #
+    # @param [String] val
+    #   the build version to set
+    # @param [Proc] block
+    #   the block to run when constructing the +build_version+
+    #
+    # @return [String]
+    #
+    def build_version(val = NULL, &block)
+      if block && !null?(val)
+        raise Error, 'You cannot specify additional parameters to ' \
+          '#build_version when a block is given!'
+      end
+
+      if block
+        @build_version_dsl = BuildVersionDSL.new(&block)
       else
-        if !val.equal?(NULL_ARG)
-          @build_version_dsl = BuildVersionDSL.new(val)
-        else
+        if null?(val)
           @build_version_dsl.build_version
+        else
+          @build_version_dsl = BuildVersionDSL.new(val)
         end
       end
     end
+    expose :build_version
 
-    # Set or retrieve the build iteration of the project.  Defaults to
-    # `1` if not otherwise set.
     #
-    # @param val [Fixnum]
+    # Set or retrieve the build iteration of the project. Defaults to +1+ if not
+    # otherwise set.
+    #
+    # @example
+    #   build_iteration 5
+    #
+    # @param [Fixnum] val
+    #   the build iteration number
+    #
     # @return [Fixnum]
     #
-    # @todo Is there a better name for this than "build_iteration"?
-    #   Would be nice to cut down confusiton with {#iteration}.
-    def build_iteration(val = NULL_ARG)
-      @build_iteration = val unless val.equal?(NULL_ARG)
-      @build_iteration || 1
-    end
-
-    def mac_pkg_identifier(val = NULL_ARG)
-      @mac_pkg_identifier = val unless val.equal?(NULL_ARG)
-      @mac_pkg_identifier
+    def build_iteration(val = NULL)
+      if null?(val)
+        @build_iteration ||= 1
+      else
+        @build_iteration = val
+      end
     end
+    expose :build_iteration
 
-    # Set or retrieve the {deb/rpm/solaris}-user fpm argument.
     #
-    # @param val [String]
-    # @return [String]
-    def package_user(val = NULL_ARG)
-      @pkg_user = val unless val.equal?(NULL_ARG)
-      @pkg_user
-    end
-
-    # Set or retrieve the full overrides hash for all software being overridden.  Calling it as
-    # a setter does not merge hash entries and will obliterate any previous overrides that have been setup.
+    # The identifer for the mac package.
     #
-    # @param val [Hash]
-    # @return [Hash]
-    def overrides(val = NULL_ARG)
-      @overrides = val unless val.equal?(NULL_ARG)
-      @overrides
-    end
-
-    # Set or retrieve the overrides hash for one piece of software being overridden.  Calling it as a
-    # setter does not merge hash entries and it will set all the overrides for a given software definition.
+    # @example
+    #   mac_pkg_identifier 'com.getchef.chefdk'
     #
-    # @param val [Hash]
-    # @return [Hash]
-    def override(name, val = NULL_ARG)
-      @overrides[name] = val unless val.equal?(NULL_ARG)
-      @overrides[name]
-    end
-
-    # Set or retrieve the {deb/rpm/solaris}-group fpm argument.
+    # @param [String] val
+    #   the package identifier
     #
-    # @param val [String]
     # @return [String]
-    def package_group(val = NULL_ARG)
-      @pkg_group = val unless val.equal?(NULL_ARG)
-      @pkg_group
-    end
-
-    # Set or retrieve the resources path to be used by packagers.
     #
-    # @param val [String]
-    # @return [String]
-    def resources_path(val = NULL_ARG)
-      @resources_path = val unless val.equal?(NULL_ARG)
-      @resources_path
+    def mac_pkg_identifier(val = NULL)
+      if null?(val)
+        @mac_pkg_identifier
+      else
+        @mac_pkg_identifier = val
+      end
     end
+    expose :mac_pkg_identifier
 
-    # Add an Omnibus software dependency.
     #
-    # Note that this is a *build time* dependency.  If you need to
-    # specify an external dependency that is required at runtime, see
-    # {#runtime_dependency} instead.
+    # Set or retrieve the +{deb/rpm/solaris}-user+ fpm argument.
     #
-    # @param val [String] the name of a Software dependency
-    # @return [void]
-    def dependency(val)
-      @dependencies << val
-    end
-
-    # Add a package that is a runtime dependency of this
-    # project.
+    # @example
+    #   package_user 'build'
     #
-    # This is distinct from a build-time dependency, which should
-    # correspond to an Omnibus software definition.
+    # @param [String] val
+    #   the user to retrive for the fpm build
     #
-    # Corresponds to the `--depends` flag of
-    # {https://github.com/jordansissel/fpm fpm}.
+    # @return [String]
     #
-    # @param val [String] the name of the runtime dependency
-    # @return [void]
-    def runtime_dependency(val)
-      @runtime_dependencies << val
+    def package_user(val = NULL)
+      if null?(val)
+        @package_user
+      else
+        @package_user = val
+      end
     end
+    expose :package_user
 
-    # Set or retrieve the list of software dependencies for this
-    # project.  As this is a DSL method, only pass the names of
-    # software components, not {Omnibus::Software} objects.
     #
-    # These is the software that comprises your project, and is
-    # distinct from runtime dependencies.
+    # Set or retrieve the overrides hash for one piece of software being
+    # overridden. Calling it as a setter does not merge hash entries and it will
+    # set all the overrides for a given software definition.
     #
-    # @note This will reinitialize the internal depdencies Array
-    #   and overwrite any dependencies that may have been set using
-    #   {#dependency}.
-    #
-    # @param val [Array<String>] a list of names of Software components
-    # @return [Array<String>]
-    def dependencies(val = NULL_ARG)
-      @dependencies = val unless val.equal?(NULL_ARG)
-      @dependencies
-    end
-
-    # Add a new exclusion pattern.
+    # @example
+    #   override 'chef', version: '1.2.3'
     #
-    # Corresponds to the `--exclude` flag of {https://github.com/jordansissel/fpm fpm}.
+    # @param [Hash] val
+    #   the value to override
     #
-    # @param pattern [String]
-    # @return void
-    def exclude(pattern)
-      @exclusions << pattern
-    end
-
-    # Add a config file.
+    # @return [Hash]
     #
-    # @param val [String] the name of a config file of your software
-    # @return [void]
-    def config_file(val)
-      @config_files << val
+    def override(name, val = NULL)
+      if null?(val)
+        overrides[name]
+      else
+        overrides[name] = val
+      end
     end
+    expose :override
 
-    # Add other files or dirs outside of install_path
     #
-    # @param val [String] the name of a dir or file to include in build
-    # @return [void]
-    # NOTE: This option is currently only supported with FPM based package
-    # builds such as RPM, DEB and .sh (makeselfinst).  This isn't supported
-    # on Mac OSX packages, Windows MSI, AIX and Solaris
-    def extra_package_file(val)
-      @extra_package_files << val
-    end
-
-    # Set or retrieve the array of files and directories used to
-    # build this project. If you use this to write, only pass the
-    # full path to the dir or file you want included in the omnibus
-    # package build.
+    # Set or retrieve the +{deb/rpm/solaris}+-group fpm argument.
     #
-    # @note - similar to the depdencies array - this will reinitialize
-    # the files array and overwrite and dependencies that were set using
-    # {#file}.
+    # @example
+    #   package_group 'build'
     #
-    # @param val [Array<String>] a list of names of Software components
-    # @return [Array<String>]
-    def extra_package_files(val = NULL_ARG)
-      @extra_package_files = val unless val.equal?(NULL_ARG)
-      @extra_package_files
-    end
-
-    # Returns the platform version of the machine on which Omnibus is
-    # running, as determined by Ohai.
+    # @param [String] val
+    #   the group to retrive for the fpm build
     #
     # @return [String]
-    def platform_version
-      Ohai.platform_version
-    end
-
-    # Returns the platform of the machine on which Omnibus is running,
-    # as determined by Ohai.
     #
-    # @return [String]
-    def platform
-      Ohai.platform
+    def package_group(val = NULL)
+      if null?(val)
+        @package_group
+      else
+        @package_group = val
+      end
     end
+    expose :package_group
 
-    # Returns the platform family of the machine on which Omnibus is
-    # running, as determined by Ohai.
     #
-    # @return [String]
-    def platform_family
-      Ohai.platform_family
-    end
-
-    def machine
-      Ohai['kernel']['machine']
-    end
-
-    # Convenience method for accessing the global Omnibus configuration object.
+    # Set or retrieve the resources path to be used by packagers.
     #
-    # @return Omnibus::Config
+    # @example
+    #   resources_path '/path/to/resources'
     #
-    # @see Omnibus::Config
-    def config
-      Omnibus.config
+    # @param [String] val
+    #   the path where resources live
+    #
+    # @return [String]
+    #
+    def resources_path(val = NULL)
+      if null?(val)
+        @resources_path
+      else
+        @resources_path = val
+      end
     end
+    expose :resources_path
 
+    #
     # The path to the package scripts directory for this project.
     # These are optional scripts that can be bundled into the
     # resulting package for running at various points in the package
@@ -583,55 +548,563 @@ module Omnibus
     # scripts directory will be incorporated into the package that is
     # built.  This only applies to fpm-built packages.
     #
-    # Additionally, there may be a `makeselfinst` script.
+    # Additionally, there may be a +makeselfinst+ script.
     #
     # @return [String]
     #
-    # @todo This documentation really should be up at a higher level,
-    #   particularly since the user has no way to change the path.
-    def package_scripts_path
-      "#{Omnibus.project_root}/package-scripts/#{name}"
+    def package_scripts_path(arg = NULL)
+      if null?(arg)
+        @package_scripts_path || "#{Config.project_root}/package-scripts/#{name}"
+      else
+        @package_scripts_path = arg
+      end
     end
+    expose :package_scripts_path
 
-    # Path to the /files directory in the omnibus project. This directory can
-    # contain assets used for creating packages (e.g., Mac .pkg files and
-    # Windows MSIs can be installed by GUI which can optionally be customized
-    # with background images, license agreements, etc.)
     #
-    # This method delegates to the Omnibus.project_root module function so that
-    # Packagers classes rely only on the Project object for their inputs.
+    # Add a software dependency.
     #
-    # @return [String] path to the files directory.
-    def files_path
-      "#{Omnibus.project_root}/files"
+    # Note that this is a *build time* dependency. If you need to specify an
+    # external dependency that is required at runtime, see {#runtime_dependency}
+    # instead.
+    #
+    # @example
+    #   dependency 'foo'
+    #   dependency 'bar'
+    #
+    # @param [String] val
+    #   the name of a Software dependency
+    #
+    # @return [Array<String>]
+    #   the list of dependencies
+    #
+    def dependency(val)
+      dependencies << val
+      dependencies.dup
+    end
+    expose :dependency
+
+    #
+    # Add a package that is a runtime dependency of this project.
+    #
+    # This is distinct from a build-time dependency, which should correspond to
+    # a software definition.
+    #
+    # Corresponds to the +--depends+ flag of
+    # {https://github.com/jordansissel/fpm fpm}.
+    #
+    # @example
+    #   runtime_dependency 'foo'
+    #
+    # @param [String] val
+    #   the name of the runtime dependency
+    #
+    # @return [Array<String>]
+    #   the list of runtime dependencies
+    #
+    def runtime_dependency(val)
+      runtime_dependencies << val
+      runtime_dependencies.dup
+    end
+    expose :runtime_dependency
+
+    #
+    # Add a new exclusion pattern.
+    #
+    # Corresponds to the +--exclude+ flag of
+    # {https://github.com/jordansissel/fpm fpm}.
+    #
+    # @example
+    #   exclude 'foo'
+    #
+    # @param [String] pattern
+    #   the thing to exclude
+    #
+    # @return [Array<String>]
+    #   the list of current exclusions
+    #
+    def exclude(pattern)
+      exclusions << pattern
+      exclusions.dup
+    end
+    expose :exclude
+
+    #
+    # Add a config file.
+    #
+    # @example
+    #   config_file '/path/to/config.rb'
+    #
+    # @param [String] val
+    #   the name of a config file of your software
+    #
+    # @return [Array<String>]
+    #   the list of current config files
+    #
+    def config_file(val)
+      config_files << val
+      config_files.dup
+    end
+    expose :config_file
+
+    #
+    # Add other files or dirs outside of +install_dir+.
+    #
+    # @note This option is currently only supported with FPM based package
+    # builds such as RPM, DEB and .sh (makeselfinst).  This is not supported
+    # on Mac OSX packages, Windows MSI, AIX and Solaris
+    #
+    # @example
+    #   extra_package_file '/path/to/file'
+    #
+    # @param [String] val
+    #   the name of a dir or file to include in build
+    #
+    # @return [Array<String>]
+    #   the list of current extra package files
+    #
+    def extra_package_file(val)
+      extra_package_files << val
+      extra_package_files.dup
+    end
+    expose :extra_package_file
+
+    #
+    # The platform version of the machine on which Omnibus is running, as
+    # determined by Ohai.
+    #
+    # @deprecated Use +Ohai['platform_version']+ instead.
+    #
+    # @return [String]
+    #
+    def platform_version
+      log.deprecated(log_key) do
+        "platform_version (DSL). Please use Ohai['platform_version'] instead."
+      end
+
+      Ohai['platform_version']
+    end
+    expose :platform_version
+
+    #
+    # The platform of the machine on which Omnibus is running, as determined
+    # by Ohai.
+    #
+    # @deprecated Use +Ohai['platform']+ instead.
+    #
+    # @return [String]
+    #
+    def platform
+      log.deprecated(log_key) do
+        "platform (DSL). Please use Ohai['platform'] instead."
+      end
+
+      Ohai['platform']
+    end
+    expose :platform
+
+    #
+    # The platform family of the machine on which Omnibus is running, as
+    # determined by Ohai.
+    #
+    # @deprecated Use +Ohai['platform_family']+ instead.
+    #
+    # @return [String]
+    #
+    def platform_family
+      log.deprecated(log_key) do
+        "platform_family (DSL). Please use Ohai['platform_family'] instead."
+      end
+
+      Ohai['platform_family']
+    end
+    expose :platform_family
+
+    #
+    # The machine which this project is running on.
+    #
+    # @deprecated Use +Ohai['kernel']['machine']+ instead.
+    #
+    # @return [String]
+    #
+    def machine
+      log.deprecated(log_key) do
+        "machine (DSL). Please use Ohai['kernel']['machine'] instead."
+      end
+
+      Ohai['kernel']['machine']
+    end
+    expose :machine
+
+    #
+    # Convenience method for accessing the global Omnibus configuration object.
+    #
+    # @deprecated Use {Config} instead
+    #
+    # @return Config
+    #
+    # @see Config
+    #
+    def config
+      log.deprecated(log_key) do
+        'config (DSL). Please use Config.(thing) instead (capital C).'
+      end
+
+      Config
+    end
+    expose :config
+
+    #
+    # The list of software dependencies for this project. These is the software
+    # that comprises your project, and is distinct from runtime dependencies.
+    #
+    # @deprecated Use {#dependency} instead (as a setter; the getter will stay)
+    #
+    # @todo Remove the "setter" part of this method and unexpose it as part of
+    # the DSL in the next major release
+    #
+    # @see #dependency
+    #
+    # @param [Array<String>]
+    #
+    # @return [Array<String>]
+    #
+    def dependencies(*args)
+      @dependencies ||= []
+
+      # Handle the case where an array or list of args were given
+      flattened_args = Array(args).flatten
+
+      if flattened_args.empty?
+        @dependencies
+      else
+        log.deprecated(log_key) do
+          "dependencies (DSL). Please specify each dependency on its own " \
+          "line like `dependency '#{Array(val).first}'`."
+        end
+
+        @dependencies = flattened_args
+      end
+    end
+    expose :dependencies
+
+    #
+    # @!endgroup
+    # --------------------------------------------------
+
+    #
+    # @!group Public API
+    #
+    # In addition to the DSL methods, the following methods are considered to
+    # be the "public API" for a project.
+    # --------------------------------------------------
+
+    #
+    # The path (on disk) where this project came from. Warning: this can be
+    # +nil+ if a project was dynamically created!
+    #
+    # @return [String, nil]
+    #
+    def filepath
+      @filepath
+    end
+
+    #
+    #
+    # The list of config files for this software.
+    #
+    # @return [Array<String>]
+    #
+    def config_files
+      @config_files ||= []
+    end
+
+    #
+    # The list of files and directories used to build this project.
+    #
+    # @return [Array<String>]
+    #
+    def extra_package_files(val = NULL)
+      @extra_package_files ||= []
+    end
+
+    #
+    # The list of software dependencies for this project.
+    #
+    # These is the software that is used at runtime for your project.
+    #
+    # @return [Array<String>]
+    #
+    def runtime_dependencies
+      runtime_dependencies ||= []
+    end
+
+    #
+    # The list of things this project conflicts with.
+    #
+    # @return [Array<String>]
+    #
+    def conflicts
+      @conflicts ||= []
+    end
+
+    #
+    # The list of exclusions for this project.
+    #
+    # @return [Array<String>]
+    #
+    def exclusions
+      @exclusions ||= []
+    end
+
+    #
+    # Retrieve the list of overrides for all software being overridden.
+    #
+    # @return [Hash]
+    #
+    def overrides
+      @overrides ||= {}
+    end
+
+    #
+    # The DSL for this build version.
+    #
+    # @return [BuildVersionDSL]
+    #
+    def build_version_dsl
+      @build_version_dsl
+    end
+
+    #
+    # Indicates whether the given  +software+ is defined as a software component
+    # of this project.
+    #
+    # @param [String, Software] software
+    #   the software or name of the software to find
+    #
+    # @return [true, false]
+    #
+    def dependency?(software)
+      name = software.is_a?(Software) ? software.name : software
+      dependencies.include?(name)
+    end
+
+    #
+    # The library for this Omnibus project.
+    #
+    # @return [Library]
+    #
+    def library
+      @library ||= Library.new(self)
+    end
+
+    #
+    # Dirty the cache for this project. This can be called by other projects,
+    # install path cache, or software definitions to invalidate the cache for
+    # this project.
+    #
+    # @return [true, false]
+    #
+    def dirty!
+      @dirty = true
+    end
+
+    #
+    # Determine if the cache for this project is dirty.
+    #
+    # @return [true, false]
+    #
+    def dirty?
+      !!@dirty
+    end
+
+    #
+    # Comparator for two projects (+name+)
+    #
+    # @return [1, 0, -1]
+    #
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    # Defines the iteration for the package to be generated.  Adheres
+    # to the conventions of the platform for which the package is
+    # being built.
+    #
+    # All iteration strings begin with the value set in {#build_iteration}
+    #
+    # @return [String]
+    def iteration
+      case Ohai['platform_family']
+      when 'rhel'
+        Ohai['platform_version'] =~ /^(\d+)/
+        maj = Regexp.last_match[1]
+        "#{build_iteration}.el#{maj}"
+      when 'freebsd'
+        Ohai['platform_version'] =~ /^(\d+)/
+        maj = Regexp.last_match[1]
+        "#{build_iteration}.#{Ohai['platform']}.#{maj}.#{Ohai['kernel']['machine']}"
+      when 'windows'
+        "#{build_iteration}.windows"
+      when 'aix', 'debian', 'mac_os_x'
+        "#{build_iteration}"
+      else
+        "#{build_iteration}.#{Ohai['platform']}.#{Ohai['platform_version']}"
+      end
+    end
+
+    def build_me
+      FileUtils.mkdir_p(Config.package_dir)
+      FileUtils.rm_rf(install_dir)
+      FileUtils.mkdir_p(install_dir)
+
+      # Cache the build order so we don't re-compute
+      softwares = library.build_order
+
+      # Download all softwares first
+      softwares.each do |software|
+        software.fetch
+      end
+
+      # Now build each software
+      softwares.each do |software|
+        software.build_me
+      end
+
+      # Health check
+      HealthCheck.run!(self)
+
+      # Package
+      package_me
+    end
+
+    def package_me
+      destination = File.expand_path('pkg', Config.project_root)
+
+      # Create the destination directory
+      unless File.directory?(destination)
+        FileUtils.mkdir_p(destination)
+      end
+
+      package_types.each do |pkg_type|
+        if pkg_type == 'makeself'
+          run_makeself
+        elsif pkg_type == 'msi'
+          run_msi
+        elsif pkg_type == 'bff'
+          run_bff
+        elsif pkg_type == 'pkgmk'
+          run_pkgmk
+        elsif pkg_type == 'mac_pkg'
+          run_mac_package_build
+        elsif pkg_type == 'mac_dmg'
+          # noop, since the dmg creation is handled by the packager
+        else # pkg_type == "fpm"
+          run_fpm(pkg_type)
+        end
+
+        render_metadata(pkg_type)
+
+        if Ohai['platform'] == 'windows'
+          FileUtils.cp(Dir["#{Config.package_dir}/*.msi*"], destination)
+        elsif Ohai['platform'] == 'aix'
+          FileUtils.cp(Dir["#{Config.package_dir}/*.bff*"], destination)
+        else
+          FileUtils.cp(Dir["#{Config.package_dir}/*"], destination)
+        end
+      end
+    end
+
+    # Ensures that certain project information has been set
+    #
+    # @todo raise MissingProjectConfiguration instead of printing the warning
+    #   in the next major release
+    #
+    # @return [void]
+    def validate
+      name && install_dir && maintainer && homepage
+      if package_name == replaces
+        log.warn { BadReplacesLine.new.message }
+      end
     end
 
-    # The directory where packages are written when created. Delegates to
-    # #config. The delegation allows Packagers (like Packager::MacPkg) to
-    # define the implementation rather than using the global config everywhere.
     #
-    # @return [String] path to the package directory.
-    def package_dir
-      config.package_dir
+    # The unique "hash" for this project.
+    #
+    # @see (#shasum)
+    #
+    # @return [Fixnum]
+    #
+    def hash
+      shasum.hash
     end
 
-    # The directory where intermediate packaging products may be stored.
-    # Delegates to Config so that Packagers have a consistent API.
     #
-    # @see Config.package_tmp some caveats.
-    # @return [String] path to the package temp directory.
-    def package_tmp
-      config.package_tmp
+    # Determine if two projects are identical.
+    #
+    # @param [Project] other
+    #
+    # @return [true, false]
+    #
+    def ==(other)
+      self.hash == other.hash
     end
+    alias_method :eql?, :==
+
+    #
+    # The unique SHA256 for this project.
+    #
+    # A project is defined by its name, its build_version, its install_dir,
+    # and any overrides (as JSON). Additionally, if provided, the actual file
+    # contents are included in the SHA to ensure uniqueness.
+    #
+    # @return [String]
+    #
+    def shasum
+      @shasum ||= begin
+        digest = Digest::SHA256.new
 
+        log.info(log_key)  { "Calculating shasum" }
+        log.debug(log_key) { "name: #{name.inspect}" }
+        log.debug(log_key) { "install_dir: #{install_dir.inspect}" }
+        log.debug(log_key) { "overrides: #{overrides.inspect}" }
+
+        update_with_string(digest, name)
+        update_with_string(digest, install_dir)
+        update_with_string(digest, JSON.fast_generate(overrides))
+
+        if filepath && File.exist?(filepath)
+          log.debug(log_key) { "filepath: #{filepath.inspect}" }
+          update_with_file_contents(digest, filepath)
+        else
+          log.debug(log_key) { "filepath: <DYNAMIC>" }
+          update_with_string(digest, '<DYNAMIC>')
+        end
+
+        shasum = digest.hexdigest
+
+        log.debug(log_key) { "shasum: #{shasum.inspect}" }
+
+        shasum
+      end
+    end
+
+    #
+    # @!endgroup
+    # --------------------------------------------------
+
+    private
+
+    #
     # Determine the package type(s) to be built, based on the platform
     # family for which the package is being built.
     #
-    # If specific types cannot be determined, default to `["makeself"]`.
+    # If specific types cannot be determined, default to +["makeself"]+.
     #
     # @return [Array<(String)>]
+    #
     def package_types
-      case platform_family
+      case Ohai['platform_family']
       when 'debian'
         %w(deb)
       when 'fedora', 'rhel'
@@ -649,71 +1122,81 @@ module Omnibus
       end
     end
 
-    # Indicates whether `software` is defined as a software component
-    # of this project.
-    #
-    # @param software [String, Omnibus::Software, #name]
-    # @return [Boolean]
     #
-    # @see #dependencies
-    def dependency?(software)
-      name = if software.respond_to?(:name)
-               software.send(:name)
-             else
-               software
-             end
-      @dependencies.include?(name)
-    end
-
-    # @!endgroup
-
-    private
-
-    # An Array of platform data suitable for `Artifact.new`. This will go into
-    # metadata generated for the artifact, and be used for the file hierarchy
-    # of released packages if the default release scripts are used.
-    # @return [Array<String>] platform_shortname, platform_version_for_package,
-    #   machine architecture.
-    def platform_tuple
-      [platform_shortname, platform_version_for_package, machine]
-    end
-
     # Platform version to be used in package metadata. For rhel, the minor
     # version is removed, e.g., "5.6" becomes "5". For all other platforms,
     # this is just the platform_version.
-    # @return [String] the platform version
+    #
+    # @return [String]
+    #   the platform version
+    #
     def platform_version_for_package
-      if platform == 'rhel'
-        platform_version[/([\d]+)\..+/, 1]
+      case Ohai['platform_family']
+      when 'debian', 'fedora', 'freebsd', 'rhel'
+        if Ohai['platform'] == 'ubuntu'
+          # Only want MAJOR.MINOR (Ubuntu 12.04)
+          Ohai['platform_version'].split('.')[0..1].join('.')
+        else
+          # Only want MAJOR (Debian 7)
+          Ohai['platform_version'].split('.').first
+        end
+      when 'aix', 'arch', 'gentoo', 'mac_os_x', 'openbsd', 'slackware', 'solaris2', 'suse'
+        # Only want MAJOR.MINOR
+        Ohai['platform_version'].split('.')[0..1].join('.')
+      when 'omnios', 'smartos'
+        # Only want MAJOR
+        Ohai['platform_version'].split('.').first
+      when 'windows'
+        # Windows has this really awesome "feature", where their version numbers
+        # internally do not match the "marketing" name. Dear Microsoft, this is
+        # why we cannot have nice things.
+        case Ohai['platform_version']
+        when '6.1.7600' then '7'
+        when '6.1.7601' then '2008r2'
+        when '6.2.9200' then '8'
+        when '6.3.9200' then '8.1'
+        else
+          raise UnknownPlatformVersion.new(Ohai['platform'], Ohai['platform_version'])
+        end
       else
-        platform_version
+        raise UnknownPlatformFamily.new(Ohai['platform_family'])
       end
     end
 
+    #
     # Platform name to be used when creating metadata for the artifact.
     # rhel/centos become "el", all others are just platform
-    # @return [String] the platform family short name
+    #
+    # @return [String]
+    #   the platform family short name
+    #
     def platform_shortname
-      if platform_family == 'rhel'
+      if Ohai['platform_family'] == 'rhel'
         'el'
       else
-        platform
+        Ohai['platform']
       end
     end
 
     def render_metadata(pkg_type)
       basename = output_package(pkg_type)
-      pkg_path = "#{config.package_dir}/#{basename}"
+      pkg_path = "#{Config.package_dir}/#{basename}"
 
       # Don't generate metadata for packages that haven't been created.
       # TODO: Fix this and make it betterer
       return unless File.exist?(pkg_path)
 
-      artifact = Artifact.new(pkg_path, [platform_tuple], version: build_version)
-      metadata = artifact.flat_metadata
-      File.open("#{pkg_path}.metadata.json", 'w+') do |f|
-        f.print(JSON.pretty_generate(metadata))
-      end
+      package = Package.new(pkg_path)
+      Package::Metadata.generate(package,
+        name:             name,
+        friendly_name:    friendly_name,
+        homepage:         homepage,
+        platform:         platform_shortname,
+        platform_version: platform_version_for_package,
+        arch:             Ohai['kernel']['machine'],
+        version:          build_version,
+        iteration:        build_iteration,
+      )
     end
 
     # The basename of the resulting package file.
@@ -793,53 +1276,53 @@ module Omnibus
         command_and_opts << "--after-remove '#{File.join(package_scripts_path, "postrm")}'"
       end
 
-      @exclusions.each do |pattern|
+      exclusions.each do |pattern|
         command_and_opts << "--exclude '#{pattern}'"
       end
 
-      @config_files.each do |config_file|
+      config_files.each do |config_file|
         command_and_opts << "--config-files '#{config_file}'"
       end
 
-      @runtime_dependencies.each do |runtime_dep|
+      runtime_dependencies.each do |runtime_dep|
         command_and_opts << "--depends '#{runtime_dep}'"
       end
 
-      @conflicts.each do |conflict|
+      conflicts.each do |conflict|
         command_and_opts << "--conflicts '#{conflict}'"
       end
 
-      if @pkg_user
+      if package_user
         %w(deb rpm solaris).each do |type|
-          command_and_opts << " --#{type}-user #{@pkg_user}"
+          command_and_opts << " --#{type}-user #{package_user}"
         end
       end
 
-      if @pkg_group
+      if package_group
         %w(deb rpm solaris).each do |type|
-          command_and_opts << " --#{type}-group #{@pkg_group}"
+          command_and_opts << " --#{type}-group #{package_group}"
         end
       end
 
-      command_and_opts << " --replaces #{@replaces}" if @replaces
+      command_and_opts << " --replaces #{replaces}" if replaces
 
       # All project files must be appended to the command "last", but before
       # the final install path
-      @extra_package_files.each do |files|
+      extra_package_files.each do |files|
         command_and_opts << files
       end
 
       # Install path must be the final entry in the command
-      command_and_opts << install_path
+      command_and_opts << install_dir
       command_and_opts
     end
 
     # TODO: what's this do?
     def makeself_command
       command_and_opts = [
-        File.expand_path(File.join(Omnibus.source_root, 'bin', 'makeself.sh')),
+        Omnibus.source_root.join('bin', 'makeself.sh'),
         '--gzip',
-        install_path,
+        install_dir,
         output_package('makeself'),
         "'The full stack of #{@name}'",
       ]
@@ -854,18 +1337,18 @@ module Omnibus
       package_commands = []
       # copy the makeself installer into package
       if File.exist?("#{package_scripts_path}/makeselfinst")
-        package_commands << "cp #{package_scripts_path}/makeselfinst #{install_path}/"
+        package_commands << "cp #{package_scripts_path}/makeselfinst #{install_dir}/"
       end
 
       # run the makeself program
       package_commands << makeself_command.join(' ')
 
       # rm the makeself installer (for incremental builds)
-      package_commands << "rm -f #{install_path}/makeselfinst"
+      package_commands << "rm -f #{install_dir}/makeselfinst"
       package_commands.each { |cmd| run_package_command(cmd) }
     end
 
-    # Runs the necessary command to make an MSI. As a side-effect, sets `output_package`
+    # Runs the necessary command to make an MSI. As a side-effect, sets +output_package+
     # @return void
     def run_msi
       Packager::WindowsMsi.new(self).run!
@@ -880,15 +1363,15 @@ module Omnibus
       FileUtils.rm_rf '/tmp/bff'
       FileUtils.mkdir '/tmp/bff'
 
-      system "find #{install_path} -print > /tmp/bff/file.list"
+      system "find #{install_dir} -print > /tmp/bff/file.list"
 
       system "cat #{package_scripts_path}/aix/opscode.chef.client.template | sed -e 's/TBS/#{bff_version}/' > /tmp/bff/gen.preamble"
 
       # @todo can we just use an erb template here?
       system "cat /tmp/bff/gen.preamble /tmp/bff/file.list #{package_scripts_path}/aix/opscode.chef.client.template.last > /tmp/bff/gen.template"
 
-      FileUtils.cp "#{package_scripts_path}/aix/unpostinstall.sh", "#{install_path}/bin"
-      FileUtils.cp "#{package_scripts_path}/aix/postinstall.sh", "#{install_path}/bin"
+      FileUtils.cp "#{package_scripts_path}/aix/unpostinstall.sh", "#{install_dir}/bin"
+      FileUtils.cp "#{package_scripts_path}/aix/postinstall.sh", "#{install_dir}/bin"
 
       run_package_command(bff_command)
 
@@ -900,8 +1383,8 @@ module Omnibus
     end
 
     def run_pkgmk
-      install_dirname = File.dirname(install_path)
-      install_basename = File.basename(install_path)
+      install_dirname = File.dirname(install_dir)
+      install_basename = File.basename(install_dir)
 
       system 'sudo rm -rf /tmp/pkgmk'
       FileUtils.mkdir '/tmp/pkgmk'
@@ -959,7 +1442,7 @@ PSTAMP=#{`hostname`.chomp + Time.now.utc.iso8601}
     end
 
     # Runs the necessary command to make a package with fpm. As a side-effect,
-    # sets `output_package`
+    # sets +output_package+
     # @return void
     def run_fpm(pkg_type)
       run_package_command(fpm_command(pkg_type).join(' '))
@@ -976,7 +1459,7 @@ PSTAMP=#{`hostname`.chomp + Time.now.utc.iso8601}
         command = cmd
       end
 
-      shellout!(command, cwd: config.package_dir)
+      shellout!(command, cwd: Config.package_dir)
     end
 
     def log_key