bolt 1.49.0 → 2.0.0

data/lib/bolt/transport/local/shell.rb

@@ -164,15 +164,13 @@ module Bolt
 
             # Read from out and err
             ready_read&.each do |stream|
-              begin
-                # Check for sudo prompt
-                read_streams[stream] << if use_sudo
-                                          check_sudo(stream, inp, t.pid, options[:stdin])
-                                        else
-                                          stream.readpartial(CHUNK_SIZE)
-                                        end
-              rescue EOFError
-              end
+              # Check for sudo prompt
+              read_streams[stream] << if use_sudo
+                                        check_sudo(stream, inp, t.pid, options[:stdin])
+                                      else
+                                        stream.readpartial(CHUNK_SIZE)
+                                      end
+            rescue EOFError
             end
 
             # select will either return an empty array if there are no
@@ -204,10 +202,8 @@ module Bolt
           # Read any remaining data in the pipe. Do not wait for
           # EOF in case the pipe is inherited by a child process.
           read_streams.each do |stream, _|
-            begin
-              loop { read_streams[stream] << stream.read_nonblock(CHUNK_SIZE) }
-            rescue Errno::EAGAIN, EOFError
-            end
+            loop { read_streams[stream] << stream.read_nonblock(CHUNK_SIZE) }
+          rescue Errno::EAGAIN, EOFError
           end
           result_output.stdout << read_streams[out]
           result_output.stderr << read_streams[err]

data/lib/bolt/transport/orch.rb

@@ -56,11 +56,9 @@ module Bolt
       def finish_plan(result)
         if result.is_a? Bolt::PlanResult
           @connections.each_value do |conn|
-            begin
-              conn.finish_plan(result)
-            rescue StandardError => e
-              @logger.debug("Failed to finish plan on #{conn.key}: #{e.message}")
-            end
+            conn.finish_plan(result)
+          rescue StandardError => e
+            @logger.debug("Failed to finish plan on #{conn.key}: #{e.message}")
           end
         end
       end

data/lib/bolt/transport/ssh.rb

@@ -19,6 +19,7 @@ module Bolt
                                 "`py` both map to a task executable `task.py`) and the extension is case "\
                                 "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
                                 "Bolt Ruby interpreter by default.",
+        "load-config"        => "Whether to load system SSH configuration.",
         "password"           => "Login password.",
         "port"               => "Connection port.",
         "private-key"        => "Either the path to the private key file to use for authentication, or a "\

data/lib/bolt/transport/ssh/connection.rb

@@ -34,10 +34,7 @@ module Bolt
           @transport_logger = transport_logger
           @logger.debug("Initializing ssh connection to #{@target.safe_name}")
 
-          @sudo_password = @target.options['sudo-password']
-          # rubocop:disable Style/GlobalVars
-          @sudo_password ||= @target.password if $future
-          # rubocop:enable Style/GlobalVars
+          @sudo_password = @target.options['sudo-password'] || @target.password
 
           if target.options['private-key']&.instance_of?(String)
             begin

data/lib/bolt/transport/winrm/connection.rb

@@ -276,7 +276,7 @@ module Bolt
           if Dir.exist?(source)
             tree.open_directory(directory: dest, write: true, disposition: ::RubySMB::Dispositions::FILE_OPEN_IF)
 
-            (Dir.entries(source) - ['.', '..']).each do |child|
+            Dir.children(source).each do |child|
               child_dest = dest + '\\' + child
               write_remote_file_smb_recursive(tree, File.join(source, child), child_dest)
             end

data/lib/bolt/util.rb

@@ -104,12 +104,6 @@ module Bolt
         hash1.merge(hash2, &recursive_merge)
       end
 
-      def map_vals(hash)
-        hash.each_with_object({}) do |(k, v), acc|
-          acc[k] = yield(v)
-        end
-      end
-
       # Accepts a Data object and returns a copy with all hash keys
       # modified by block. use &:to_s to stringify keys or &:to_sym to symbolize them
       def walk_keys(data, &block)
@@ -131,7 +125,7 @@ module Bolt
       def walk_vals(data, skip_top = false, &block)
         data = yield(data) unless skip_top
         if data.is_a? Hash
-          map_vals(data) { |v| walk_vals(v, &block) }
+          data.transform_values { |v| walk_vals(v, &block) }
         elsif data.is_a? Array
           data.map { |v| walk_vals(v, &block) }
         else
@@ -144,7 +138,7 @@ module Bolt
       # parents.
       def postwalk_vals(data, skip_top = false, &block)
         new_data = if data.is_a? Hash
-                     map_vals(data) { |v| postwalk_vals(v, &block) }
+                     data.transform_values { |v| postwalk_vals(v, &block) }
                    elsif data.is_a? Array
                      data.map { |v| postwalk_vals(v, &block) }
                    else

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.49.0'
+  VERSION = '2.0.0'
 end

data/lib/bolt_server/transport_app.rb

@@ -186,17 +186,15 @@ module BoltServer
         [400, '`environment` is a required argument']
       else
         @pal_mutex.synchronize do
-          begin
-            pal = BoltServer::PE::PAL.new({}, environment)
-            yield pal
-          rescue Puppet::Environments::EnvironmentNotFound
-            [400, {
-              "class" => 'bolt/unknown-environment',
-              "message" => "Environment #{environment} not found"
-            }.to_json]
-          rescue Bolt::Error => e
-            [400, e.to_json]
-          end
+          pal = BoltServer::PE::PAL.new({}, environment)
+          yield pal
+        rescue Puppet::Environments::EnvironmentNotFound
+          [400, {
+            "class" => 'bolt/unknown-environment',
+            "message" => "Environment #{environment} not found"
+          }.to_json]
+        rescue Bolt::Error => e
+          [400, e.to_json]
         end
       end
     end
@@ -255,14 +253,23 @@ module BoltServer
         'load-config' => false
       }
 
-      opts = defaults.merge(target_hash.clone).merge(overrides)
+      opts = defaults.merge(target_hash).merge(overrides)
 
       if opts['private-key-content']
         private_key_content = opts.delete('private-key-content')
         opts['private-key'] = { 'key-data' => private_key_content }
       end
 
-      Bolt::Target.new(target_hash['hostname'], opts)
+      data = {
+        'uri' => target_hash['hostname'],
+        'config' => {
+          'transport' => 'ssh',
+          'ssh' => opts
+        }
+      }
+
+      inventory = Bolt::Inventory.empty
+      Bolt::Target.from_hash(data, inventory)
     end
 
     post '/ssh/:action' do
@@ -286,12 +293,23 @@ module BoltServer
     end
 
     def make_winrm_target(target_hash)
-      overrides = {
-        'protocol' => 'winrm'
+      defaults = {
+        'ssl' => false,
+        'ssl-verify' => false
+      }
+
+      opts = defaults.merge(target_hash)
+
+      data = {
+        'uri' => target_hash['hostname'],
+        'config' => {
+          'transport' => 'winrm',
+          'winrm' => opts
+        }
       }
 
-      opts = target_hash.clone.merge(overrides)
-      Bolt::Target.new(target_hash['hostname'], opts)
+      inventory = Bolt::Inventory.empty
+      Bolt::Target.from_hash(data, inventory)
     end
 
     post '/winrm/:action' do

data/lib/bolt_spec/plans.rb

@@ -185,10 +185,16 @@ module BoltSpec
     end
 
     # Provided as a class so expectations can be placed on it.
-    class MockPuppetDBClient; end
+    class MockPuppetDBClient
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+    end
 
     def puppetdb_client
-      @puppetdb_client ||= MockPuppetDBClient.new
+      @puppetdb_client ||= MockPuppetDBClient.new(Bolt::PuppetDB::Config.new({}))
     end
 
     def pal

data/libexec/bolt_catalog

@@ -41,12 +41,26 @@ elsif command == "compile"
             else
               JSON.parse(STDIN.read)
             end
-  catalog = Bolt::Catalog.new.compile_catalog(request)
-  # This seems to be a string in ruby 2.3
-  if catalog.is_a?(String)
-    catalog = JSON.parse(catalog)
+  begin
+    catalog = Bolt::Catalog.new.compile_catalog(request)
+    # This seems to be a string in ruby 2.3
+    if catalog.is_a?(String)
+      catalog = JSON.parse(catalog)
+    end
+    puts JSON.pretty_generate(catalog)
+  rescue Puppet::PreformattedError => e
+    message = if e.cause
+                location_info = Puppet::Util::Errors.error_location_with_space(e.file, e.line, e.pos)
+                "#{e.cause.message}#{location_info}"
+              else
+                e.message
+              end
+    puts({ message: message }.to_json)
+    exit 1
+  rescue StandardError => e
+    puts({ message: e.message }.to_json)
+    exit 1
   end
-  puts JSON.pretty_generate(catalog)
 else
   puts "USAGE: run 'bolt_catalog compile' with a request on STDIN " \
        "or 'bolt_catalog parse manifest.pp' to generate JSON AST"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.49.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -343,7 +343,6 @@ email:
 - puppet@puppet.com
 executables:
 - bolt
-- bolt-inventory-pdb
 extensions: []
 extra_rdoc_files: []
 files:
@@ -388,7 +387,6 @@ files:
 - bolt-modules/out/lib/puppet/functions/out/message.rb
 - bolt-modules/system/lib/puppet/functions/system/env.rb
 - exe/bolt
-- exe/bolt-inventory-pdb
 - lib/bolt.rb
 - lib/bolt/analytics.rb
 - lib/bolt/applicator.rb
@@ -405,8 +403,7 @@ files:
 - lib/bolt/executor.rb
 - lib/bolt/inventory.rb
 - lib/bolt/inventory/group.rb
-- lib/bolt/inventory/group2.rb
-- lib/bolt/inventory/inventory2.rb
+- lib/bolt/inventory/inventory.rb
 - lib/bolt/inventory/target.rb
 - lib/bolt/logger.rb
 - lib/bolt/module.rb
@@ -473,7 +470,6 @@ files:
 - lib/bolt/util.rb
 - lib/bolt/util/puppet_log_level.rb
 - lib/bolt/version.rb
-- lib/bolt_ext/puppetdb_inventory.rb
 - lib/bolt_server/acl.rb
 - lib/bolt_server/base_config.rb
 - lib/bolt_server/config.rb
@@ -528,7 +524,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/exe/bolt-inventory-pdb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bolt_ext/puppetdb_inventory'
-
-begin
-  Bolt::PuppetDBInventory::CLI.new(ARGV).run
-  exit 0
-rescue StandardError => e
-  warn "Error: #{e}"
-  warn e.backtrace if @trace
-  exit 1
-end

data/lib/bolt/inventory/group2.rb

@@ -1,403 +0,0 @@
-# frozen_string_literal: true
-
-require 'bolt/inventory/group'
-require 'bolt/inventory/inventory2'
-require 'bolt/inventory/target'
-
-module Bolt
-  class Inventory
-    class Group2
-      attr_accessor :name, :groups
-
-      # Regex used to validate group names and target aliases.
-      NAME_REGEX = /\A[a-z0-9_][a-z0-9_-]*\Z/.freeze
-
-      DATA_KEYS = %w[config facts vars features plugin_hooks].freeze
-      TARGET_KEYS = DATA_KEYS + %w[name alias uri]
-      GROUP_KEYS = DATA_KEYS + %w[name groups targets]
-      CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
-
-      def initialize(input, plugins)
-        @logger = Logging.logger[self]
-        @plugins = plugins
-
-        input = @plugins.resolve_top_level_references(input) if @plugins.reference?(input)
-
-        raise ValidationError.new("Group does not have a name", nil) unless input.key?('name')
-
-        @name = @plugins.resolve_references(input['name'])
-
-        raise ValidationError.new("Group name must be a String, not #{@name.inspect}", nil) unless @name.is_a?(String)
-        raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ NAME_REGEX
-
-        validate_group_input(input)
-
-        @input = input
-
-        validate_data_keys(@input)
-
-        targets = @plugins.resolve_top_level_references(input.fetch('targets', []))
-
-        @unresolved_targets = {}
-        @resolved_targets = {}
-
-        @aliases = {}
-        @string_targets = []
-
-        Array(targets).each do |target|
-          # If target is a string, it can either be trivially defining a target
-          # or it could be a name/alias of a target defined in another group.
-          # We can't tell the difference until all groups have been resolved,
-          # so we store the string on its own here and process it later.
-          if target.is_a?(String)
-            @string_targets << target
-          # Handle plugins at this level so that lookups cannot trigger recursive lookups
-          elsif target.is_a?(Hash)
-            add_target_definition(target)
-          else
-            raise ValidationError.new("Target entry must be a String or Hash, not #{target.class}", @name)
-          end
-        end
-
-        groups = input.fetch('groups', [])
-        # 'groups' can be a _plugin reference, in which case we want to resolve
-        # it. That can itself return a reference, so we want to keep resolving
-        # them until we have a value. We don't just use resolve_references
-        # though, since that will resolve any nested references and we want to
-        # leave it to the group to do that lazily.
-        groups = @plugins.resolve_top_level_references(groups)
-
-        @groups = Array(groups).map { |g| Group2.new(g, plugins) }
-      end
-
-      def target_data(target_name)
-        if @unresolved_targets.key?(target_name)
-          target = @unresolved_targets.delete(target_name)
-          resolved_data = resolve_data_keys(target, target_name).merge(
-            'name' => target['name'],
-            'uri' => target['uri'],
-            'alias' => target['alias'],
-            # groups come from group_data
-            'groups' => []
-          )
-          @resolved_targets[target_name] = resolved_data
-        else
-          @resolved_targets[target_name]
-        end
-      end
-
-      def all_target_names
-        @unresolved_targets.keys + @resolved_targets.keys
-      end
-
-      def add_target_definition(target)
-        # This check ensures target lookup plugins do not returns bare strings.
-        # Remove it if we decide to allows task plugins to return string Target
-        # names.
-        unless target.is_a?(Hash)
-          raise ValidationError.new("Target entry must be a Hash, not #{target.class}", @name)
-        end
-
-        target['name'] = @plugins.resolve_references(target['name']) if target.key?('name')
-        target['uri'] = @plugins.resolve_references(target['uri']) if target.key?('uri')
-        target['alias'] = @plugins.resolve_references(target['alias']) if target.key?('alias')
-
-        t_name = target['name'] || target['uri']
-
-        if t_name.nil? || t_name.empty?
-          raise ValidationError.new("No name or uri for target: #{target}", @name)
-        end
-
-        unless t_name.is_a? String
-          raise ValidationError.new("Target name must be a String, not #{t_name.class}", @name)
-        end
-
-        unless t_name.ascii_only?
-          raise ValidationError.new("Target name must be ASCII characters: #{target}", @name)
-        end
-
-        if local_targets.include?(t_name)
-          @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
-          return
-        end
-
-        unless (unexpected_keys = target.keys - TARGET_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{t_name}"
-          @logger.warn(msg)
-        end
-
-        validate_data_keys(target, t_name)
-
-        if target.include?('alias')
-          aliases = target['alias']
-          aliases = [aliases] if aliases.is_a?(String)
-          unless aliases.is_a?(Array)
-            msg = "Alias entry on #{t_name} must be a String or Array, not #{aliases.class}"
-            raise ValidationError.new(msg, @name)
-          end
-
-          insert_alia(t_name, aliases)
-        end
-
-        @unresolved_targets[t_name] = target
-      end
-
-      def remove_target(target)
-        @resolved_targets.delete(target.name)
-        @unresolved_targets.delete(target.name)
-      end
-
-      def add_target(target)
-        @resolved_targets[target.name] = { 'name' => target.name }
-      end
-
-      def insert_alia(target_name, aliases)
-        aliases.each do |alia|
-          raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
-
-          if (found = @aliases[alia])
-            raise ValidationError.new(alias_conflict(alia, found, target_name), @name)
-          end
-          @aliases[alia] = target_name
-        end
-      end
-
-      def clear_alia(target_name)
-        @aliases.reject! { |_alias, name| name == target_name }
-      end
-
-      def data_merge(data1, data2)
-        if data2.nil? || data1.nil?
-          return data2 || data1
-        end
-
-        {
-          'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
-          'name' => data1['name'] || data2['name'],
-          'uri' => data1['uri'] || data2['uri'],
-          # Collect all aliases across all groups for each target uri
-          'alias' => [*data1['alias'], *data2['alias']],
-          # Shallow merge instead of deep merge so that vars with a hash value
-          # are assigned a new hash, rather than merging the existing value
-          # with the value meant to replace it
-          'vars' => data1['vars'].merge(data2['vars']),
-          'facts' => Bolt::Util.deep_merge(data1['facts'], data2['facts']),
-          'features' => data1['features'] | data2['features'],
-          'plugin_hooks' => data1['plugin_hooks'].merge(data2['plugin_hooks']),
-          'groups' => data2['groups'] + data1['groups']
-        }
-      end
-
-      def resolve_string_targets(aliases, known_targets)
-        @string_targets.each do |string_target|
-          # If this is the name of a target defined elsewhere, then insert the
-          # target into this group as just a name. Otherwise, add a new target
-          # with the string as the URI.
-          if known_targets.include?(string_target)
-            @unresolved_targets[string_target] = { 'name' => string_target }
-          # If this is an alias for an existing target, then add it to this group
-          elsif (canonical_name = aliases[string_target])
-            if local_targets.include?(canonical_name)
-              @logger.warn("Ignoring duplicate target in #{@name}: #{canonical_name}")
-            else
-              @unresolved_targets[canonical_name] = { 'name' => canonical_name }
-            end
-          # If it's not the name or alias of an existing target, then make a
-          # new target using the string as the URI
-          elsif local_targets.include?(string_target)
-            @logger.warn("Ignoring duplicate target in #{@name}: #{string_target}")
-          else
-            @unresolved_targets[string_target] = { 'uri' => string_target }
-          end
-        end
-
-        @groups.each { |g| g.resolve_string_targets(aliases, known_targets) }
-      end
-
-      private def alias_conflict(name, target1, target2)
-        "Alias #{name} refers to multiple targets: #{target1} and #{target2}"
-      end
-
-      private def group_alias_conflict(name)
-        "Group #{name} conflicts with alias of the same name"
-      end
-
-      private def group_target_conflict(name)
-        "Group #{name} conflicts with target of the same name"
-      end
-
-      private def alias_target_conflict(name)
-        "Target name #{name} conflicts with alias of the same name"
-      end
-
-      def validate_group_input(input)
-        raise ValidationError.new("Expected group to be a Hash, not #{input.class}", nil) unless input.is_a?(Hash)
-
-        # DEPRECATION : remove this before finalization
-        if input.key?('target-lookups')
-          msg = "'target-lookups' are no longer a separate key. Merge 'target-lookups' and 'targets' lists and replace 'plugin' with '_plugin'" # rubocop:disable Layout/LineLength
-          raise ValidationError.new(msg, @name)
-        end
-
-        unless (unexpected_keys = input.keys - GROUP_KEYS).empty?
-          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in group #{@name}"
-          @logger.warn(msg)
-        end
-
-        Bolt::Util.walk_keys(input) do |key|
-          if @plugins.reference?(key)
-            raise ValidationError.new("Group keys cannot be specified as _plugin references", @name)
-          else
-            key
-          end
-        end
-      end
-
-      def validate(used_group_names = Set.new, used_target_names = Set.new, used_aliases = {})
-        # Test if this group name conflicts with anything used before.
-        raise ValidationError.new("Tried to redefine group #{@name}", @name) if used_group_names.include?(@name)
-        raise ValidationError.new(group_target_conflict(@name), @name) if used_target_names.include?(@name)
-        raise ValidationError.new(group_alias_conflict(@name), @name) if used_aliases.include?(@name)
-
-        used_group_names << @name
-
-        # Collect target names and aliases into a list used to validate that subgroups don't conflict.
-        # Used names validate that previously used group names don't conflict with new target names/aliases.
-        @unresolved_targets.merge(@resolved_targets).each do |t_name, t_data|
-          # Require targets to be parseable as a Target.
-          begin
-            # Catch malformed URI here
-            Bolt::Inventory::Target.parse_uri(t_data['uri'])
-          rescue Bolt::ParseError => e
-            @logger.debug(e)
-            raise ValidationError.new("Invalid target uri #{t_data['uri']}", @name)
-          end
-
-          raise ValidationError.new(group_target_conflict(t_name), @name) if used_group_names.include?(t_name)
-          if used_aliases.include?(t_name)
-            raise ValidationError.new(alias_target_conflict(t_name), @name)
-          end
-
-          used_target_names << t_name
-        end
-
-        @aliases.each do |n, target|
-          raise ValidationError.new(group_alias_conflict(n), @name) if used_group_names.include?(n)
-          if used_target_names.include?(n)
-            raise ValidationError.new(alias_target_conflict(n), @name)
-          end
-
-          if used_aliases.include?(n)
-            raise ValidationError.new(alias_conflict(n, target, used_aliases[n]), @name)
-          end
-
-          used_aliases[n] = target
-        end
-
-        @groups.each do |g|
-          begin
-            g.validate(used_group_names, used_target_names, used_aliases)
-          rescue ValidationError => e
-            e.add_parent(@name)
-            raise e
-          end
-        end
-
-        nil
-      end
-
-      def resolve_data_keys(data, target = nil)
-        result = {
-          'config' => @plugins.resolve_references(data.fetch('config', {})),
-          'vars' => @plugins.resolve_references(data.fetch('vars', {})),
-          'facts' => @plugins.resolve_references(data.fetch('facts', {})),
-          'features' => @plugins.resolve_references(data.fetch('features', [])),
-          'plugin_hooks' => @plugins.resolve_references(data.fetch('plugin_hooks', {}))
-        }
-        validate_data_keys(result, target)
-        result['features'] = Set.new(result['features'].flatten)
-        result
-      end
-
-      def validate_data_keys(data, target = nil)
-        {
-          'config' => Hash,
-          'vars' => Hash,
-          'facts' => Hash,
-          'features' => Array,
-          'plugin_hooks' => Hash
-        }.each do |key, expected_type|
-          next if !data.key?(key) || data[key].is_a?(expected_type) || @plugins.reference?(data[key])
-
-          msg = +"Expected #{key} to be of type #{expected_type}, not #{data[key].class}"
-          msg << " for target #{target}" if target
-          raise ValidationError.new(msg, @name)
-        end
-        unless @plugins.reference?(data['config'])
-          unexpected_keys = data.fetch('config', {}).keys - CONFIG_KEYS
-          if unexpected_keys.any?
-            msg = +"Found unexpected key(s) #{unexpected_keys.join(', ')} in config for"
-            msg << " target #{target} in" if target
-            msg << " group #{@name}"
-            @logger.warn(msg)
-          end
-        end
-      end
-
-      def group_data
-        @group_data ||= resolve_data_keys(@input).merge('groups' => [@name])
-      end
-
-      # Returns targets contained directly within the group, ignoring subgroups
-      def local_targets
-        Set.new(@unresolved_targets.keys) + Set.new(@resolved_targets.keys)
-      end
-
-      # Returns all targets contained within the group, which includes targets from subgroups.
-      def all_targets
-        @groups.inject(local_targets) do |acc, g|
-          acc.merge(g.all_targets)
-        end
-      end
-
-      # Returns a mapping of aliases to targets contained within the group, which includes subgroups.
-      def target_aliases
-        @groups.inject(@aliases) do |acc, g|
-          acc.merge(g.target_aliases)
-        end
-      end
-
-      # Return a mapping of group names to group.
-      def collect_groups
-        @groups.inject(name => self) do |acc, g|
-          acc.merge(g.collect_groups)
-        end
-      end
-
-      def target_collect(target_name)
-        child_data = @groups.map { |group| group.target_collect(target_name) }
-        # Data from earlier groups wins
-        child_result = child_data.inject do |acc, group_data|
-          data_merge(group_data, acc)
-        end
-        # Children override the parent
-        data_merge(target_data(target_name), child_result)
-      end
-
-      def group_collect(target_name)
-        child_data = @groups.map { |group| group.group_collect(target_name) }
-        # Data from earlier groups wins
-        child_result = child_data.inject do |acc, group_data|
-          data_merge(group_data, acc)
-        end
-
-        # If this group has the target or one of the child groups has the
-        # target, return the data, otherwise return nil
-        if child_result || local_targets.include?(target_name)
-          # Children override the parent
-          data_merge(group_data, child_result)
-        end
-      end
-    end
-  end
-end