chef-dk 0.13.21 → 0.14.25

data/tasks/bundle.rb

@@ -17,10 +17,11 @@
 
 require_relative "bundle_util"
 require_relative "../version_policy"
+require "fileutils"
 
 desc "Tasks to work with the main Gemfile and Gemfile.<platform>"
 namespace :bundle do
-  desc "Update Gemfile.lock and all Gemfile.<platform>.locks (or one or more gems via bundle:update gem1 gem2 ...). NOTE: use rake dependencies:update_current_chef to update the version of chef first, if you want it updated as well)."
+  desc "Update Gemfile.lock and all Gemfile.<platform>.locks (or one or more gems via bundle:update gem1 gem2 ...)."
   task :update, [:args] do |t, rake_args|
     extend BundleUtil
     args = rake_args[:args] || ""
@@ -31,11 +32,7 @@ namespace :bundle do
       puts "-------------------------------------------------------------------"
       bundle "install #{args}", delete_gemfile_lock: true
       platforms.each do |platform|
-        puts ""
-        puts "-------------------------------------------------------------------"
-        puts "Updating Gemfile.#{platform}.lock ..."
-        puts "-------------------------------------------------------------------"
-        bundle "lock", gemfile: "Gemfile.#{platform}", platform: platform, delete_gemfile_lock: true
+        bundle "lock", platform: platform
       end
     end
   end
@@ -51,18 +48,37 @@ namespace :bundle do
       puts "-------------------------------------------------------------------"
       bundle "install #{args}"
       platforms.each do |platform|
+        bundle "lock", platform: platform
+      end
+    end
+  end
+
+  # Find out if we're using the latest gems we can (so we don't regress versions)
+  desc "Check for gems that are not at the latest released version, and report if anything not in ACCEPTABLE_OUTDATED_GEMS (version_policy.rb) is out of date."
+  task :outdated do
+    extend BundleUtil
+    puts ""
+    puts "-------------------------------------------------------------------"
+    puts "Checking for outdated gems ..."
+    puts "-------------------------------------------------------------------"
+    with_bundle_unfrozen do
+      bundle_outdated = bundle("outdated", extract_output: true)
+      puts bundle_outdated
+      outdated_gems = parse_bundle_outdated(bundle_outdated).map { |line, gem_name| gem_name }
+      # Weed out the acceptable ones
+      outdated_gems = outdated_gems.reject { |gem_name| ACCEPTABLE_OUTDATED_GEMS.include?(gem_name) }
+      if outdated_gems.empty?
         puts ""
-        puts "-------------------------------------------------------------------"
-        puts "Updating Gemfile.#{platform}.lock (conservatively) ..."
-        puts "-------------------------------------------------------------------"
-        bundle "lock", gemfile: "Gemfile.#{platform}", platform: platform
+        puts "SUCCESS!"
+      else
+        raise "ERROR: outdated gems: #{outdated_gems.join(", ")}. Either fix them or add them to ACCEPTABLE_OUTDATED_GEMS in #{__FILE__}."
       end
     end
   end
 end
 
 desc "Run bundle with arbitrary args against the given platform; e.g. rake bundle[show]. No platform to run against the main bundle; bundle[show,windows] to run the windows one; bundle[show,*] to run against all non-default platforms."
-task :bundle, [:args,:platform] do |t, rake_args|
+task :bundle, [:args, :platform] do |t, rake_args|
   extend BundleUtil
   args = rake_args[:args] || ""
   platform = rake_args[:platform]

data/tasks/bundle_util.rb

@@ -1,4 +1,5 @@
-require 'shellwords'
+require "bundler"
+require "shellwords"
 
 module BundleUtil
   PLATFORMS = { "windows" => %w{ruby x86-mingw32} }
@@ -24,12 +25,12 @@ module BundleUtil
     result
   end
 
-  def with_bundle_unfrozen
-    bundle "config --delete frozen"
+  def with_bundle_unfrozen(cwd: nil, leave_frozen: false)
+    bundle "config --delete frozen", cwd: cwd
     begin
       yield
     ensure
-      bundle "config --local frozen 1"
+      bundle "config --local frozen 1", cwd: cwd unless leave_frozen
     end
   end
 
@@ -56,7 +57,7 @@ module BundleUtil
 
         # Run the bundle command
         ruby_platforms = platform ? PLATFORMS[platform].join(" ") : "ruby"
-        cmd = Shellwords.join([bundle_platform, ruby_platforms, *args])
+        cmd = Shellwords.join([Gem.ruby, "-S", bundle_platform, ruby_platforms, *args])
         puts "#{prefix}#{Shellwords.join(["bundle", *args])}#{platform ? " for #{platform} platform" : ""}:"
         with_gemfile(gemfile) do
           puts "#{prefix}BUNDLE_GEMFILE=#{gemfile}"

data/tasks/dependencies.rb

@@ -18,158 +18,133 @@
 require_relative "bundle_util"
 require_relative "bundle"
 require_relative "../version_policy"
+require_relative "helpers"
 
 desc "Tasks to update and check dependencies"
 namespace :dependencies do
   # Update all dependencies to the latest constraint-matching version
-  desc "Update all dependencies. dependencies:update[conservative] to update as little as possible."
-  task :update, [:conservative] => %w{
-                    dependencies:update_current_chef
+  desc "Update all dependencies."
+  task :update => %w{
+                    dependencies:update_stable_channel_gems
                     dependencies:update_gemfile_lock
                     dependencies:update_omnibus_overrides
                     dependencies:update_omnibus_gemfile_lock
                     dependencies:update_acceptance_gemfile_lock
                   }
 
-  desc "Update Gemfile.lock and all Gemfile.<platform>.locks. update_gemfile_lock[conservative] to update as little as possible."
-  task :update_gemfile_lock, [:conservative] do |t, rake_args|
-    conservative = rake_args[:conservative]
-    if conservative
-      Rake::Task["bundle:install"].invoke
-    else
-      Rake::Task["bundle:update"].invoke
+  desc "Update Gemfile.lock and all Gemfile.<platform>.locks."
+  task :update_gemfile_lock do |t, rake_args|
+    Rake::Task["bundle:update"].invoke
+  end
+
+  def gemfile_lock_task(task_name, dirs: [], other_platforms: true, leave_frozen: true)
+    dirs.each do |dir|
+      desc "Update #{dir}/Gemfile.lock."
+      task task_name do |t, rake_args|
+        extend BundleUtil
+        puts ""
+        puts "-------------------------------------------------------------------"
+        puts "Updating #{dir}/Gemfile.lock ..."
+        puts "-------------------------------------------------------------------"
+        with_bundle_unfrozen(cwd: dir, leave_frozen: leave_frozen) do
+          bundle "install", cwd: dir, delete_gemfile_lock: true
+          if other_platforms
+            # Include all other supported platforms into the lockfile as well
+            platforms.each do |platform|
+              bundle "lock", cwd: dir, platform: platform
+            end
+          end
+        end
+      end
     end
   end
 
-  desc "Update omnibus/Gemfile.lock. update_omnibus_gemfile_lock[conservative] to update as little as possible."
-  task :update_omnibus_gemfile_lock, [:conservative] do |t, rake_args|
-    extend BundleUtil
-    conservative = rake_args[:conservative]
-    puts ""
-    puts "-------------------------------------------------------------------"
-    puts "Updating omnibus/Gemfile.lock#{conservative ? " (conservatively)" : ""} ..."
-    puts "-------------------------------------------------------------------"
-    bundle "install", cwd: "omnibus", delete_gemfile_lock: !conservative
+  def berksfile_lock_task(task_name, dirs: [])
+    dirs.each do |dir|
+      desc "Update #{dir}/Berksfile.lock."
+      task task_name do |t, rake_args|
+        extend BundleUtil
+        puts ""
+        puts "-------------------------------------------------------------------"
+        puts "Updating #{dir}/Berksfile.lock ..."
+        puts "-------------------------------------------------------------------"
+        if File.exist?("#{project_root}/#{dir}/Berksfile.lock")
+          File.delete("#{project_root}/#{dir}/Berksfile.lock")
+        end
+        Dir.chdir("#{project_root}/#{dir}") do
+          Bundler.with_clean_env do
+            sh "bundle exec berks install"
+          end
+        end
+      end
+    end
   end
 
-  desc "Update acceptance/Gemfile.lock (or one or more gems via update[gem1,gem2,...]). update_acceptance_gemfile_lock[conservative] to update as little as possible."
-  task :update_acceptance_gemfile_lock, [:conservative] do |t, rake_args|
+  include RakeDependenciesTaskHelpers
+
+  gemfile_lock_task :update_omnibus_gemfile_lock, dirs: %w{omnibus}
+  gemfile_lock_task :update_acceptance_gemfile_lock, dirs: %w{acceptance},
+    other_platforms: false, leave_frozen: false
+
+  desc "Update gems to the versions specified by the stable channel."
+  task :update_stable_channel_gems do |t, rake_args|
     extend BundleUtil
-    conservative = rake_args[:conservative]
     puts ""
     puts "-------------------------------------------------------------------"
-    puts "Updating acceptance/Gemfile.lock#{conservative ? " (conservatively)" : ""} ..."
+    puts "Updating Gemfile ..."
     puts "-------------------------------------------------------------------"
-    bundle "install", cwd: "acceptance", delete_gemfile_lock: !conservative
-  end
 
-  desc "Update current chef release in Gemfile. update_current_chef[conservative] does nothing."
-  task :update_current_chef, [:conservative] do |t, rake_args|
-    extend BundleUtil
-    conservative = rake_args[:conservative]
-    unless conservative
-      puts ""
-      puts "-------------------------------------------------------------------"
-      puts "Updating Gemfile ..."
-      puts "-------------------------------------------------------------------"
-
-      require "mixlib/install"
-      # TODO in some edge cases, stable will actually be the latest chef because
-      # promotion *moves* the package out of current into stable rather than
-      # copying
-      puts "Getting latest chef 'current' version from omnitruck ..."
-      options = {
-        channel: :current,
-        product_name: 'chef',
-        product_version: :latest
-      }
-      version = Mixlib::Install.new(options).artifact_info.first.version
-
-      # Modify the gemfile to pin to current chef
-      gemfile_path = File.join(project_root, "Gemfile")
-      gemfile = IO.read(gemfile_path)
-      found = gemfile.sub!(/^(\s*gem "chef", github: "chef\/chef", branch: ")([^"]*)(")$/m) do
-        if $2 != "v#{version}"
-          puts "Setting chef version in Gemfile to v#{version} (was #{$2})"
-        else
-          puts "chef version in Gemfile already at latest current (#{$2})"
-        end
-        "#{$1}v#{version}#{$3}"
-      end
-      unless found
-        raise "Gemfile does not have a line of the form 'gem \"chef\", github: \"chef/chef\", branch: \"v<version>\"', so we didn't update it to latest current (v#{version}). Remove dependencies:update_current_chef from the `dependencies:update` rake task to prevent it from being run if this is intentional."
-      end
+    # Modify the gemfile to pin to stable chef
+    gemfile_path = File.join(project_root, "Gemfile")
+    gemfile = IO.read(gemfile_path)
+    update_gemfile_from_stable(gemfile, "chef", "chef", "v")
+    update_gemfile_from_stable(gemfile, "push-jobs-client", "opscode-pushy-client")
 
-      if gemfile != IO.read(gemfile_path)
-        puts "Writing modified #{gemfile_path} ..."
-        IO.write(gemfile_path, gemfile)
-      end
+    if gemfile != IO.read(gemfile_path)
+      puts "Writing modified #{gemfile_path} ..."
+      IO.write(gemfile_path, gemfile)
     end
   end
 
-  desc "Update omnibus overrides, including versions in version_policy.rb and latest version of gems: #{OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.keys}. update_omnibus_overrides[conservative] does nothing."
-  task :update_omnibus_overrides, [:conservative] do |t, rake_args|
-    conservative = rake_args[:conservative]
-    unless conservative
-      puts ""
-      puts "-------------------------------------------------------------------"
-      puts "Updating omnibus_overrides.rb ..."
-      puts "-------------------------------------------------------------------"
-
-      # Generate the new overrides file
-      overrides = "# Generated by \"rake dependencies\". Do not edit.\n"
-
-      # Replace the bundler and rubygems versions
-      OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.each do |override_name, gem_name|
-        # Get the latest bundler version
-        puts "Running gem list -re #{gem_name} ..."
-        gem_list = `gem list -re #{gem_name}`
-        unless gem_list =~ /^#{gem_name}\s*\(([^)]*)\)$/
-          raise "gem list -re #{gem_name} failed with output:\n#{gem_list}"
-        end
+  desc "Update omnibus overrides, including versions in version_policy.rb and latest version of gems: #{OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.keys}."
+  task :update_omnibus_overrides do |t, rake_args|
+    puts ""
+    puts "-------------------------------------------------------------------"
+    puts "Updating omnibus_overrides.rb ..."
+    puts "-------------------------------------------------------------------"
 
-        # Emit it
-        puts "Latest version of #{gem_name} is #{$1}"
-        overrides << "override #{override_name.inspect}, version: #{$1.inspect}\n"
-      end
+    # Generate the new overrides file
+    overrides = "# DO NOT EDIT. Generated by \"rake dependencies\". Edit version_policy.rb instead.\n"
 
-      # Add explicit overrides
-      OMNIBUS_OVERRIDES.each do |override_name, version|
-        overrides << "override #{override_name.inspect}, version: #{version.inspect}\n"
+    # Replace the bundler and rubygems versions
+    OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.each do |override_name, gem_name|
+      # Get the latest bundler version
+      puts "Running gem list -r #{gem_name} ..."
+      gem_list = `gem list -r #{gem_name}`
+      unless gem_list =~ /^#{gem_name}\s*\(([^)]*)\)$/
+        raise "gem list -r #{gem_name} failed with output:\n#{gem_list}"
       end
 
-      # Write the file out (if changed)
-      overrides_path = File.expand_path("../../omnibus_overrides.rb", __FILE__)
-      if overrides != IO.read(overrides_path)
-        puts "Overrides changed!"
-        puts `git diff #{overrides_path}`
-        puts "Writing modified #{overrides_path} ..."
-        IO.write(overrides_path, overrides)
-      end
+      # Emit it
+      puts "Latest version of #{gem_name} is #{$1}"
+      overrides << "override #{override_name.inspect}, version: #{$1.inspect}\n"
     end
-  end
 
-  # Find out if we're using the latest gems we can (so we don't regress versions)
-  desc "Check for gems that are not at the latest released version, and report if anything not in ACCEPTABLE_OUTDATED_GEMS (version_policy.rb) is out of date."
-  task :check_outdated do
-    puts ""
-    puts "-------------------------------------------------------------------"
-    puts "Checking for outdated gems ..."
-    puts "-------------------------------------------------------------------"
-    # TODO check for outdated windows gems too
-    bundle_outdated = bundle("outdated", extract_output: true)
-    puts bundle_outdated
-    outdated_gems = parse_bundle_outdated(bundle_outdated).map { |line, gem_name| gem_name }
-    # Weed out the acceptable ones
-    outdated_gems = outdated_gems.reject { |gem_name| ACCEPTABLE_OUTDATED_GEMS.include?(gem_name) }
-    if outdated_gems.empty?
-      puts ""
-      puts "SUCCESS!"
-    else
-      raise "ERROR: outdated gems: #{outdated_gems.join(", ")}. Either fix them or add them to ACCEPTABLE_OUTDATED_GEMS in #{__FILE__}."
+    # Add explicit overrides
+    OMNIBUS_OVERRIDES.each do |override_name, version|
+      overrides << "override #{override_name.inspect}, version: #{version.inspect}\n"
+    end
+
+    # Write the file out (if changed)
+    overrides_path = File.expand_path("../../omnibus_overrides.rb", __FILE__)
+    if overrides != IO.read(overrides_path)
+      puts "Overrides changed!"
+      puts `git diff #{overrides_path}`
+      puts "Writing modified #{overrides_path} ..."
+      IO.write(overrides_path, overrides)
     end
   end
 end
-desc "Update all dependencies and check for outdated gems. Call dependencies[conservative] to update as little as possible."
-task :dependencies, [:conservative] => [ "dependencies:update", "dependencies:check_outdated" ]
-task :update, [:conservative] => [ "dependencies:update", "dependencies:check_outdated"]
+desc "Update all dependencies and check for outdated gems."
+task :dependencies => [ "dependencies:update", "bundle:outdated" ]
+task :update => [ "dependencies:update", "bundle:outdated"]

data/tasks/gemfile_util.rb

@@ -1,99 +1,390 @@
+require "rubygems"
 require "bundler"
+require "shellwords"
+require "set"
 
 module GemfileUtil
   #
-  # Given a set of dependencies with groups in them, and a resolved set of
-  # gemspecs (with dependency info in them), creates a full set of specs
-  # with group information on it. If A is in groups x and y, and A depends on
-  # B and C, then B and C are also in groups x and y.
+  # Adds `override: true`, which allows your statement to override any other
+  # gem statement about the same gem in the Gemfile.
   #
-  class GemGroups < Hash
-    def initialize(resolved)
-      @resolved = resolved
+  def gem(name, *args)
+    options = args[-1].is_a?(Hash) ? args[-1] : {}
+
+    # Unless we're finished with everything, ignore gems that are being overridden
+    unless overridden_gems == :finished
+      # If it's a path or override gem, it overrides whatever else is there.
+      if options[:path] || options[:override]
+        options.delete(:override)
+        warn_if_replacing(name, overridden_gems[name], args)
+        overridden_gems[name] = args
+        return
+
+      # If there's an override gem, and we're *not* an override gem, don't do anything
+      elsif overridden_gems[name]
+        warn_if_replacing(name, args, overridden_gems[name])
+        return
+      end
+    end
+
+    # Otherwise, add the gem normally
+    super
+  rescue
+    puts $!.backtrace
+    raise
+  end
+
+  def overridden_gems
+    @overridden_gems ||= {}
+  end
+
+  #
+  # Just before we finish the Gemfile, finish up the override gems
+  #
+  def to_definition(*args)
+    complete_overrides
+    super
+  end
+
+  def complete_overrides
+    to_override = overridden_gems
+    unless to_override == :finished
+      @overridden_gems = :finished
+      to_override.each do |name, args|
+        gem name, *args
+      end
     end
-    attr_reader :resolved
+  end
 
-    def add_dependency(dep)
-      add_gem_groups(dep.name, dep.groups)
+  #
+  # Include all gems in the locked gemfile.
+  #
+  # @param gemfile_path Path to the Gemfile to load (relative to your Gemfile)
+  # @param lockfile_path Path to the Gemfile to load (relative to your Gemfile).
+  #          Defaults to <gemfile_path>.lock.
+  # @param groups A list of groups to include (whitelist). If not passed (or set
+  #          to nil), all gems will be selected.
+  # @param without_groups A list of groups to ignore. Gems will be excluded from
+  #          the results if all groups they belong to are ignored. This matches
+  #          bundler's `without` behavior.
+  # @param gems A list of gems to include above and beyond the given groups.
+  #          Gems in this list must be explicitly included in the Gemfile
+  #          with a `gem "gem_name", ...` line or they will be silently
+  #          ignored.
+  # @param copy_groups Whether to copy the groups over from the old lockfile to
+  #          the new. Use this when the new lockfile has the same convention for
+  #          groups as the old. Defaults to `false`.
+  #
+  def include_locked_gemfile(gemfile_path, lockfile_path = "#{gemfile_path}.lock", groups: nil, without_groups: nil, gems: [], copy_groups: false)
+    # Parse the desired lockfile
+    gemfile_path = Pathname.new(gemfile_path).expand_path(Bundler.default_gemfile.dirname).realpath
+    lockfile_path = Pathname.new(lockfile_path).expand_path(Bundler.default_gemfile.dirname).realpath
+
+    # Calculate relative_to
+    relative_to = Bundler.default_gemfile.dirname.realpath
+
+    # Call out to create-override-gemfile to read the Gemfile+Gemfile.lock (bundler does not work well if you do two things in one process)
+    create_override_gemfile_bin = File.expand_path("../bin/create-override-gemfile", __FILE__)
+    arguments = [
+      "--gemfile", gemfile_path,
+      "--lockfile", lockfile_path,
+      "--override"
+    ]
+    arguments += [ "--relative-to", relative_to ] if relative_to != "."
+    arguments += Array(groups).flat_map { |group| [ "--group", group ] }
+    arguments += Array(without_groups).flat_map { |without| [ "--without", without ] }
+    arguments += Array(gems).flat_map { |name| [ "--gem", name ] }
+    arguments << "--copy-groups" if copy_groups
+    cmd = Shellwords.join([ Gem.ruby, "-S", create_override_gemfile_bin, *arguments ])
+    output = nil
+    Bundler.ui.info("> #{cmd}")
+    Bundler.with_clean_env do
+      output = `#{cmd}`
     end
+    instance_eval(output, cmd, 1)
+  end
 
-    private
+  #
+  # Include all gems in the locked gemfile.
+  #
+  # @param current_gemfile The Gemfile you are currently loading (`self`).
+  # @param gemfile_path Path to the Gemfile to load (relative to your Gemfile)
+  # @param lockfile_path Path to the Gemfile to load (relative to your Gemfile).
+  #          Defaults to <gemfile_path>.lock.
+  # @param groups A list of groups to include (whitelist). If not passed (or set
+  #          to nil), all gems will be selected.
+  # @param without_groups A list of groups to ignore. Gems will be excluded from
+  #          the results if all groups they belong to are ignored. This matches
+  #          bundler's `without` behavior.
+  # @param gems A list of gems to include above and beyond the given groups.
+  #          Gems in this list must be explicitly included in the Gemfile
+  #          with a `gem "gem_name", ...` line or they will be silently
+  #          ignored.
+  # @param copy_groups Whether to copy the groups over from the old lockfile to
+  #          the new. Use this when the new lockfile has the same convention for
+  #          groups as the old. Defaults to `false`.
+  #
+  def self.include_locked_gemfile(current_gemfile, gemfile_path, lockfile_path = "#{gemfile_path}.lock", groups: nil, without_groups: nil, gems: [], copy_groups: false)
+    current_gemfile.instance_eval do
+      extend GemfileUtil
+      include_locked_gemfile(gemfile_path, lockfile_path, groups: groups, without_groups: without_groups, gems: gems, copy_groups: copy_groups)
+    end
+  end
+
+  def warn_if_replacing(name, old_args, new_args)
+    return if !old_args || !new_args
+    if args_to_dep(name, *old_args) =~ args_to_dep(name, *new_args)
+      Bundler.ui.debug "Replaced Gemfile dependency #{name} (#{old_args}) with (#{new_args})"
+    else
+      Bundler.ui.warn "Replaced Gemfile dependency #{name} (#{old_args}) with (#{new_args})"
+    end
+  end
+
+  def args_to_dep(name, *version, **options)
+    version = [">= 0"] if version.empty?
+    Bundler::Dependency.new(name, version, options)
+  end
+
+  #
+  # Reads a bundle, including a gemfile and lockfile.
+  #
+  # Does no validation, does not update the lockfile or its gems in any way.
+  #
+  class Bundle
+    #
+    # Parse the given gemfile/lockfile pair.
+    #
+    # @return [Bundle] The parsed bundle.
+    #
+    def self.parse(gemfile_path, lockfile_path = "#{gemfile_path}.lock")
+      result = new(gemfile_path, lockfile_path)
+      result.gems
+      result
+    end
+
+    #
+    # Create a new Bundle to parse the given gemfile/lockfile pair.
+    #
+    def initialize(gemfile_path, lockfile_path = "#{gemfile_path}.lock")
+      @gemfile_path = gemfile_path
+      @lockfile_path = lockfile_path
+    end
+
+    #
+    # The path to the Gemfile
+    #
+    attr_reader :gemfile_path
+
+    #
+    # The path to the Lockfile
+    #
+    attr_reader :lockfile_path
 
-    def add_gem_groups(name, groups)
-      self[name] ||= []
-      difference = groups - self[name]
-      unless difference.empty?
-        self[name] += difference
-        spec = resolved.find { |spec| spec.name == name }
-        if spec
-          spec.dependencies.each do |spec|
-            add_gem_groups(spec.name, difference)
+    #
+    # The list of gems.
+    #
+    # @return [Hash<String, Hash>] The resulting gems, where key = gem_name, and the
+    #           hash has:
+    #           - version: version of the gem.
+    #           - source info (:source/:git/:ref/:path) from the lockfile
+    #           - dependencies: A list of gem names this gem has a runtime
+    #             dependency on. Dependencies are transitive: if A depends on B,
+    #             and B depends on C, then A has C in its :dependencies list.
+    #           - development_dependencies: - A list of gem names this gem has a
+    #             development dependency on. Dependencies are transitive: if A
+    #             depends on B, and B depends on C, then A has C in its
+    #             :development_dependencies list. development dependencies *include*
+    #             runtime dependencies.
+    #           - groups: The list of groups (symbols) this gem is in. Groups
+    #             are transitive: if A has a runtime dependency on B, and A is
+    #             in group X, then B is also in group X.
+    #           - declared_groups: The list of groups (symbols) this gem was
+    #             declared in the Gemfile.
+    #
+    def gems
+      @gems ||= begin
+        gems = locks.dup
+        gems.each do |name, g|
+          if gem_declarations.has_key?(name)
+            g[:declared_groups] = gem_declarations[name][:groups]
+          else
+            g[:declared_groups] = []
+          end
+          g[:groups] = g[:declared_groups].dup
+        end
+        # Transitivize groups (since dependencies are already transitive, this is easy)
+        gems.each do |name, g|
+          g[:dependencies].each do |dep|
+            gems[dep][:groups] |= gems[name][:declared_groups].dup
           end
         end
+        gems
       end
     end
-  end
 
-  def calculate_dependents(spec_set)
-    dependents = {}
-    spec_set.each do |spec|
-      dependents[spec] ||= []
+    #
+    # Get the gems (and their deps) in the given group.
+    #
+    # @param groups A list of groups to include (whitelist). If not passed (or set
+    #          to nil), all gems will be selected.
+    # @param without_groups A list of groups to ignore. Gems will be excluded from
+    #          the results if all groups they belong to are ignored.
+    #          This matches bundler's `without` behavior.
+    # @param gems A list of gems to include regardless of what groups are included.
+    #
+    # @return Hash[String, Hash] The resulting gems, where key = gem_name, and the
+    #           hash has:
+    #           - version: version of the gem.
+    #           - source info (:source/:git/:ref/:path) from the lockfile
+    #           - dependencies: A list of gem names this gem has a runtime
+    #             dependency on. Dependencies are transitive: if A depends on B,
+    #             and B depends on C, then A has C in its :dependencies list.
+    #           - development_dependencies: - A list of gem names this gem has a
+    #             development dependency on. Dependencies are transitive: if A
+    #             depends on B, and B depends on C, then A has C in its
+    #             :development_dependencies list. development dependencies
+    #             *include* runtime dependencies.
+    #           - groups: The list of groups (symbols) this gem is in. Groups
+    #             are transitive: if A has a runtime dependency on B, and A is
+    #             in group X, then B is also in group X.
+    #           - declared_groups: The list of groups (symbols) this gem was
+    #             declared in the Gemfile.
+    #
+    def select_gems(groups: nil, without_groups: nil)
+      # First, select the gems that match
+      result = {}
+      gems.each do |name, g|
+        dep_groups = g[:declared_groups] - [ :only_a_runtime_dependency_of_other_gems ]
+        dep_groups = dep_groups & groups if groups
+        dep_groups = dep_groups - without_groups if without_groups
+        if dep_groups.any?
+          result[name] ||= g
+          g[:dependencies].each do |dep|
+            result[dep] ||= gems[dep]
+          end
+        end
+      end
+      result
     end
-    spec_set.each do |spec|
-      spec.dependencies.each do |dep|
-        puts "#{dep.class} -> #{spec.class}"
-        dependents[dep] << spec
+
+    #
+    # Get all locks from the given lockfile.
+    #
+    # @return Hash[String, Hash] The resulting gems, where key = gem_name, and the
+    #           hash has:
+    #           - version: version of the gem.
+    #           - source info (:source/:git/:ref/:path)
+    #           - dependencies: A list of gem names this gem has a runtime
+    #             dependency on. Dependencies are transitive: if A depends on B,
+    #             and B depends on C, then A has C in its :dependencies list.
+    #           - development_dependencies: - A list of gem names this gem has a
+    #             development dependency on. Dependencies are transitive: if A
+    #             depends on B, and B depends on C, then A has C in its
+    #             :development_dependencies list. development dependencies *include*
+    #             runtime dependencies.
+    #
+    def locks
+      @locks ||= begin
+        # Grab all the specs from the lockfile
+        locks = {}
+        parsed_lockfile = Bundler::LockfileParser.new(IO.read(lockfile_path))
+        parsed_lockfile.specs.each do |spec|
+          # Never include bundler, it can't be bundled and doesn't put itself in
+          # the lockfile correctly anyway
+          next if spec.name == "bundler"
+          # Only the platform-specific locks for now (TODO make it possible to emit all locks)
+          next if spec.platform && spec.platform != Gem::Platform::RUBY
+          lock = lock_source_metadata(spec)
+          lock[:version] = spec.version.to_s
+          runtime = spec.dependencies.select { |dep| dep.type == :runtime }
+          lock[:dependencies] = Set.new(runtime.map { |dep| dep.name })
+          lock[:development_dependencies] = Set.new(spec.dependencies.map { |dep| dep.name })
+          lock[:dependencies].delete("bundler")
+          lock[:development_dependencies].delete("bundler")
+          locks[spec.name] = lock
+        end
+
+        # Transitivize the deps.
+        locks.each do |name, lock|
+          # Not all deps were brought over (platform-specific ones) so weed them out
+          lock[:dependencies] &= locks.keys
+          lock[:development_dependencies] &= locks.keys
+
+          lock[:dependencies] = transitive_dependencies(locks, name, :dependencies)
+          lock[:development_dependencies] = transitive_dependencies(locks, name, :development_dependencies)
+        end
+
+        locks
       end
     end
-    dependents
-  end
 
-  def include_locked_gemfile(gemfile)
     #
-    # Read the gemfile and inject its locks as first-class dependencies
+    # Get all desired gems, sans dependencies, from the gemfile.
+    #
+    # @param gemfile Path to the Gemfile to load
     #
-    current_source = nil
-    bundle = Bundler::Definition.build(gemfile, "#{gemfile}.lock", nil)
+    # @return Hash<String, Hash> An array of hashes where key = gem name and value
+    #           has :groups (an array of symbols representing the groups the gem
+    #           is in). :groups are not transitive, since we don't know the
+    #           dependency tree yet.
+    #
+    def gem_declarations
+      @gem_declarations ||= begin
+        Bundler.with_clean_env do
+          # Set BUNDLE_GEMFILE to the new gemfile temporarily so all bundler's things work
+          # This works around some issues in bundler 1.11.2.
+          ENV["BUNDLE_GEMFILE"] = gemfile_path
+
+          parsed_gemfile = Bundler::Dsl.new
+          parsed_gemfile.eval_gemfile(gemfile_path)
+          parsed_gemfile.complete_overrides if parsed_gemfile.respond_to?(:complete_overrides)
 
-    # Go through and create the actual gemfile from the given locks and
-    # groups.
-    bundle.resolve.sort_by { |spec| spec.name }.each do |spec|
-      # bundler can't be installed by bundler so don't pin it.
-      next if spec.name == "bundler"
-      dep = bundle.dependencies.find { |d| d.name == spec.name}
-      gem_metadata = ""
-      if dep
-        gem_metadata << ", groups: #{dep.groups.inspect}" if dep.groups != [:default]
-        gem_metadata << ", platforms: #{dep.platforms.inspect}" if dep.platforms && !dep.platforms.empty?
+          result = {}
+          parsed_gemfile.dependencies.each do |dep|
+            groups = dep.groups.empty? ? [:default] : dep.groups
+            result[dep.name] = { groups: groups, platforms: dep.platforms }
+          end
+          result
+        end
       end
+    end
+
+    private
+
+    #
+    # Given a bunch of locks (name -> { dependencies: [name,name] }) and a
+    # dependency name, add its dependencies to the result transitively.
+    #
+    def transitive_dependencies(locks, name, dep_key, result = Set.new)
+      locks[name][dep_key].each do |dep|
+        # Only ever add a dep once, so we don't infinitely recurse
+        if result.add?(dep)
+          transitive_dependencies(locks, dep, dep_key, result)
+        end
+      end
+      result
+    end
+
+    #
+    # Get source and version metadata for the given Bundler spec (coming from a lockfile).
+    #
+    # @return Hash { version: <version>, git: <git>, path: <path>, source: <source>, ref: <ref> }
+    #
+    def lock_source_metadata(spec)
+      # Copy source information from included Gemfile
+      result = {}
       case spec.source
       when Bundler::Source::Rubygems
-        if current_source
-          if current_source != spec.source
-            raise "Gem #{spec.name} has source #{spec.source}, but other gems have #{current_source}. Multiple rubygems sources are not supported."
-          end
-        else
-          current_source = spec.source
-          add_gemfile_line("source #{spec.source.remotes.first.to_s.inspect}", __LINE__)
-        end
-        add_gemfile_line("gem #{spec.name.inspect}, #{spec.version.to_s.inspect}#{gem_metadata}", __LINE__)
+        result[:source] = spec.source.remotes.first.to_s
       when Bundler::Source::Git
-        add_gemfile_line("gem #{spec.name.inspect}, git: #{spec.source.uri.to_s.inspect}, ref: #{spec.source.revision.inspect}#{gem_metadata}", __LINE__)
+        result[:git] = spec.source.uri.to_s
+        result[:ref] = spec.source.revision
       when Bundler::Source::Path
-        add_gemfile_line("gem #{spec.name.inspect}, path: #{spec.source.path.to_s.inspect}#{gem_metadata}", __LINE__)
+        result[:path] = spec.source.path.to_s
       else
         raise "Unknown source #{spec.source} for gem #{spec.name}"
       end
+      result
     end
-  rescue
-    puts $!
-    puts $!.backtrace
-    raise
-  end
-
-  private
-
-  def add_gemfile_line(line, lineno)
-    instance_eval(line, __FILE__, lineno)
   end
 end