pdk 1.14.1 → 1.18.1

data/lib/pdk/generate/defined_type.rb

@@ -3,47 +3,40 @@ require 'pdk'
 module PDK
   module Generate
     class DefinedType < PuppetObject
-      OBJECT_TYPE = :defined_type
       PUPPET_STRINGS_TYPE = 'defined_types'.freeze
 
-      # Prepares the data needed to render the new defined type template.
-      #
-      # @return [Hash{Symbol => Object}] a hash of information that will be
-      # provided to the defined type and defined type spec templates during
-      # rendering.
-      def template_data
-        data = { name: object_name }
+      def initialize(*_args)
+        super
+        object_name_parts = @object_name.split('::')
 
-        data
+        @object_name = if object_name_parts.first == module_name
+                         object_name
+                       else
+                         [module_name, object_name].join('::')
+                       end
       end
 
-      # Calculates the path to the .pp file that the new defined type will be
-      # written to.
-      #
-      # @return [String] the path where the new defined type will be written.
-      def target_object_path
-        @target_pp_path ||= begin
-          define_name_parts = object_name.split('::')[1..-1]
-          define_name_parts << 'init' if define_name_parts.empty?
-
-          "#{File.join(module_dir, 'manifests', *define_name_parts)}.pp"
-        end
+      def friendly_name
+        'Defined Type'.freeze
       end
 
-      # Calculates the path to the file where the tests for the new defined
-      # type will be written.
-      #
-      # @return [String] the path where the tests for the new defined type
-      # will be written.
-      def target_spec_path
-        @target_spec_path ||= begin
-          define_name_parts = object_name.split('::')
+      def template_files
+        # Calculate the defined type tests name
+        define_name_parts = object_name.split('::')
+        # drop the module name if the object name contains multiple parts
+        define_name_parts.delete_at(0) if define_name_parts.length > 1
+        files = { 'defined_type_spec.erb' => File.join('spec', 'defines', *define_name_parts) + '_spec.rb' }
+        return files if spec_only?
+
+        define_name_parts = object_name.split('::')[1..-1]
+        define_name_parts << 'init' if define_name_parts.empty?
+        files['defined_type.erb'] = File.join('manifests', *define_name_parts) + '.pp'
 
-          # drop the module name if the object name contains multiple parts
-          define_name_parts.delete_at(0) if define_name_parts.length > 1
+        files
+      end
 
-          "#{File.join(module_dir, 'spec', 'defines', *define_name_parts)}_spec.rb"
-        end
+      def template_data
+        { name: object_name }
       end
     end
   end

data/lib/pdk/generate/module.rb

@@ -3,8 +3,6 @@ require 'pdk'
 module PDK
   module Generate
     class Module
-      extend PDK::Util::Filesystem
-
       def self.validate_options(opts)
         require 'pdk/cli/util/option_validator'
 
@@ -16,28 +14,26 @@ module PDK
           raise PDK::CLI::ExitWithError, error_msg
         end
 
-        target_dir = File.expand_path(opts[:target_dir])
-        raise PDK::CLI::ExitWithError, _("The destination directory '%{dir}' already exists") % { dir: target_dir } if File.exist?(target_dir)
+        target_dir = PDK::Util::Filesystem.expand_path(opts[:target_dir])
+        raise PDK::CLI::ExitWithError, _("The destination directory '%{dir}' already exists") % { dir: target_dir } if PDK::Util::Filesystem.exist?(target_dir)
       end
 
       def self.invoke(opts = {})
-        require 'pdk/module/templatedir'
         require 'pdk/util'
         require 'pdk/util/template_uri'
-        require 'fileutils'
         require 'pathname'
 
         validate_options(opts) unless opts[:module_name].nil?
 
         metadata = prepare_metadata(opts)
 
-        target_dir = File.expand_path(opts[:target_dir] || opts[:module_name])
+        target_dir = PDK::Util::Filesystem.expand_path(opts[:target_dir] || opts[:module_name])
         parent_dir = File.dirname(target_dir)
 
         begin
           test_file = File.join(parent_dir, '.pdk-test-writable')
-          write_file(test_file, 'This file was created by the Puppet Development Kit to test if this folder was writable, you can safely remove this file.')
-          FileUtils.rm_f(test_file)
+          PDK::Util::Filesystem.write_file(test_file, 'This file was created by the Puppet Development Kit to test if this folder was writable, you can safely remove this file.')
+          PDK::Util::Filesystem.rm_f(test_file)
         rescue Errno::EACCES
           raise PDK::CLI::FatalError, _("You do not have permission to write to '%{parent_dir}'") % {
             parent_dir: parent_dir,
@@ -50,18 +46,30 @@ module PDK
 
         template_uri = PDK::Util::TemplateURI.new(opts)
 
+        if template_uri.default? && template_uri.default_ref?
+          PDK.logger.info _('Using the default template-url and template-ref.')
+        else
+          PDK.logger.info _(
+            "Using the %{method} template-url and template-ref '%{template_uri}'." % {
+              method: opts.key?(:'template-url') ? _('specified') : _('saved'),
+              template_uri: template_uri.metadata_format,
+            },
+          )
+        end
+
         begin
-          PDK::Module::TemplateDir.new(template_uri, metadata.data, true) do |templates|
-            templates.render do |file_path, file_content, file_status|
-              next if file_status == :delete
-              file = Pathname.new(temp_target_dir) + file_path
+          context = PDK::Context::None.new(temp_target_dir)
+          PDK::Template.with(template_uri, context) do |template_dir|
+            template_dir.render_new_module(metadata.data['name'], metadata.data) do |relative_file_path, file_content, file_status|
+              next if [:delete, :unmanage].include?(file_status)
+              file = Pathname.new(temp_target_dir) + relative_file_path
               file.dirname.mkpath
-              write_file(file, file_content)
+              PDK::Util::Filesystem.write_file(file, file_content)
             end
 
             # Add information about the template used to generate the module to the
             # metadata (for a future update command).
-            metadata.update!(templates.metadata)
+            metadata.update!(template_dir.metadata)
 
             metadata.write!(File.join(temp_target_dir, 'metadata.json'))
           end
@@ -71,19 +79,19 @@ module PDK
 
         # Only update the answers files after metadata has been written.
         require 'pdk/answer_file'
-        if template_uri.default?
+        if template_uri.default? && template_uri.default_ref?
           # If the user specifies our default template url via the command
           # line, remove the saved template-url answer so that the template_uri
           # resolution can find new default URLs in the future.
-          PDK.answers.update!('template-url' => nil) if opts.key?(:'template-url')
+          PDK.config.set(%w[user module_defaults template-url], nil) if opts.key?(:'template-url')
         else
           # Save the template-url answers if the module was generated using a
           # template/reference other than ours.
-          PDK.answers.update!('template-url' => template_uri.metadata_format)
+          PDK.config.set(%w[user module_defaults template-url], template_uri.metadata_format)
         end
 
         begin
-          if FileUtils.mv(temp_target_dir, target_dir)
+          if PDK::Util::Filesystem.mv(temp_target_dir, target_dir)
             unless opts[:'skip-bundle-install']
               Dir.chdir(target_dir) do
                 require 'pdk/util/bundler'
@@ -91,8 +99,13 @@ module PDK
               end
             end
 
-            PDK.logger.info _('Module \'%{name}\' generated at path \'%{path}\', from template \'%{url}\'.') % { name: opts[:module_name], path: target_dir, url: template_uri.git_remote }
-            PDK.logger.info(_('In your module directory, add classes with the \'pdk new class\' command.'))
+            PDK.logger.info _("Module '%{name}' generated at path '%{path}'.") % {
+              name: opts[:module_name],
+              path: target_dir,
+            }
+            PDK.logger.info _(
+              "In your module directory, add classes with the 'pdk new class' command.",
+            )
           end
         rescue Errno::EACCES => e
           raise PDK::CLI::FatalError, _("Failed to move '%{source}' to '%{target}': %{message}") % {
@@ -123,13 +136,13 @@ module PDK
         require 'pdk/answer_file'
         require 'pdk/module/metadata'
 
-        opts[:username] = (opts[:username] || PDK.answers['forge_username'] || username_from_login).downcase
+        opts[:username] = (opts[:username] || PDK.config.get_within_scopes('module_defaults.forge_username') || username_from_login).downcase
 
         defaults = PDK::Module::Metadata::DEFAULTS.dup
 
         defaults['name'] = "#{opts[:username]}-#{opts[:module_name]}" unless opts[:module_name].nil?
-        defaults['author'] = PDK.answers['author'] unless PDK.answers['author'].nil?
-        defaults['license'] = PDK.answers['license'] unless PDK.answers['license'].nil?
+        PDK.config.with_scoped_value('module_defaults.author') { |val| defaults['author'] = val }
+        PDK.config.with_scoped_value('module_defaults.license') { |val| defaults['license'] = val }
         defaults['license'] = opts[:license] if opts.key?(:license)
 
         metadata = PDK::Module::Metadata.new(defaults)
@@ -139,8 +152,6 @@ module PDK
       end
 
       def self.prepare_module_directory(target_dir)
-        require 'fileutils'
-
         [
           File.join(target_dir, 'examples'),
           File.join(target_dir, 'files'),
@@ -149,7 +160,7 @@ module PDK
           File.join(target_dir, 'tasks'),
         ].each do |dir|
           begin
-            FileUtils.mkdir_p(dir)
+            PDK::Util::Filesystem.mkdir_p(dir)
           rescue SystemCallError => e
             raise PDK::CLI::FatalError, _("Unable to create directory '%{dir}': %{message}") % {
               dir:     dir,
@@ -269,7 +280,7 @@ module PDK
 
         interview.add_questions(questions)
 
-        if File.file?('metadata.json')
+        if PDK::Util::Filesystem.file?('metadata.json')
           puts _(
             "\nWe need to update the metadata.json file for this module, so we\'re going to ask you %{count} " \
             "questions.\n",
@@ -332,13 +343,9 @@ module PDK
         end
 
         require 'pdk/answer_file'
-        PDK.answers.update!(
-          {
-            'forge_username' => opts[:username],
-            'author'         => answers['author'],
-            'license'        => answers['license'],
-          }.delete_if { |_key, value| value.nil? },
-        )
+        PDK.config.set(%w[user module_defaults forge_username], opts[:username]) unless opts[:username].nil?
+        PDK.config.set(%w[user module_defaults author], answers['author']) unless answers['author'].nil?
+        PDK.config.set(%w[user module_defaults license], answers['license']) unless answers['license'].nil?
       end
     end
   end

data/lib/pdk/generate/provider.rb

@@ -2,75 +2,26 @@ require 'pdk'
 
 module PDK
   module Generate
-    class Provider < PuppetObject
-      OBJECT_TYPE = :provider
-
-      # Prepares the data needed to render the new defined type template.
-      #
-      # @return [Hash{Symbol => Object}] a hash of information that will be
-      # provided to the defined type and defined type spec templates during
-      # rendering.
-      def template_data
-        data = {
-          name: object_name,
-          provider_class: Provider.class_name_from_object_name(object_name),
-        }
-
-        data
-      end
-
-      def raise_precondition_error(error)
-        raise PDK::CLI::ExitWithError, _('%{error}: Creating a provider needs some local configuration in your module.' \
-          ' Please follow the docs at https://puppet.com/docs/puppet/latest/create_types_and_providers_resource_api.html.') % { error: error }
-      end
-
-      def check_preconditions
-        super
-        # These preconditions can be removed once the pdk-templates are carrying the puppet-resource_api gem by default, and have switched
-        # the default mock_with value.
-        sync_path = PDK::Util.find_upwards('.sync.yml')
-        if sync_path.nil?
-          raise_precondition_error(_('.sync.yml not found'))
-        end
-        sync = YAML.load_file(sync_path)
-        if !sync.is_a? Hash
-          raise_precondition_error(_('.sync.yml contents is not a Hash'))
-        elsif !sync.key? 'Gemfile'
-          raise_precondition_error(_('Gemfile configuration not found'))
-        elsif !sync['Gemfile'].key? 'optional'
-          raise_precondition_error(_('Gemfile.optional configuration not found'))
-        elsif !sync['Gemfile']['optional'].key? ':development'
-          raise_precondition_error(_('Gemfile.optional.:development configuration not found'))
-        elsif sync['Gemfile']['optional'][':development'].none? { |g| g['gem'] == 'puppet-resource_api' }
-          raise_precondition_error(_('puppet-resource_api not found in the Gemfile config'))
-        elsif !sync.key? 'spec/spec_helper.rb'
-          raise_precondition_error(_('spec/spec_helper.rb configuration not found'))
-        elsif !sync['spec/spec_helper.rb'].key? 'mock_with'
-          raise_precondition_error(_('spec/spec_helper.rb.mock_with configuration not found'))
-        elsif !sync['spec/spec_helper.rb']['mock_with'] == ':rspec'
-          raise_precondition_error(_('spec/spec_helper.rb.mock_with not set to \':rspec\''))
-        end
-      end
-
-      # @return [String] the path where the new provider will be written.
-      def target_object_path
-        @target_object_path ||= File.join(module_dir, 'lib', 'puppet', 'provider', object_name, object_name) + '.rb'
+    class Provider < ResourceAPIObject
+      def friendly_name
+        'Resource API Provider'.freeze
       end
 
-      # @return [String] the path where the new type will be written.
-      def target_type_path
-        @target_type_path ||= File.join(module_dir, 'lib', 'puppet', 'type', object_name) + '.rb'
-      end
-
-      # @return [String] the path where the tests for the new provider
-      # will be written.
-      def target_spec_path
-        @target_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'provider', object_name, object_name) + '_spec.rb'
+      def template_files
+        files = {
+          'provider_spec.erb'      => File.join('spec', 'unit', 'puppet', 'provider', object_name, object_name) + '_spec.rb',
+          'provider_type_spec.erb' => File.join('spec', 'unit', 'puppet', 'type', object_name) + '_spec.rb',
+        }
+        return files if spec_only?
+        files.merge(
+          'provider.erb' => File.join('lib', 'puppet', 'provider', object_name, object_name) + '.rb',
+          'provider_type.erb' => File.join('lib', 'puppet', 'type', object_name) + '.rb',
+        )
       end
 
-      # @return [String] the path where the tests for the new type will be written.
-      def target_type_spec_path
-        @target_type_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'type', object_name) + '_spec.rb'
+      def template_data
+        { name: object_name,
+          provider_class: class_name_from_object_name(object_name) }
       end
     end
   end

data/lib/pdk/generate/puppet_class.rb

@@ -3,46 +3,40 @@ require 'pdk'
 module PDK
   module Generate
     class PuppetClass < PuppetObject
-      OBJECT_TYPE = :class
       PUPPET_STRINGS_TYPE = 'puppet_classes'.freeze
 
-      # Prepares the data needed to render the new Puppet class template.
-      #
-      # @return [Hash{Symbol => Object}] a hash of information that will be
-      # provided to the class and class spec templates during rendering.
-      def template_data
-        data = { name: object_name }
+      def initialize(*_args)
+        super
+        object_name_parts = @object_name.split('::')
 
-        data
+        @object_name = if object_name_parts.first == module_name
+                         object_name
+                       else
+                         [module_name, object_name].join('::')
+                       end
       end
 
-      # Calculates the path to the .pp file that the new class will be written
-      # to.
-      #
-      # @return [String] the path where the new class will be written.
-      def target_object_path
-        @target_pp_path ||= begin
-          class_name_parts = object_name.split('::')[1..-1]
-          class_name_parts << 'init' if class_name_parts.empty?
-
-          "#{File.join(module_dir, 'manifests', *class_name_parts)}.pp"
-        end
+      def friendly_name
+        'Puppet Class'.freeze
       end
 
-      # Calculates the path to the file where the tests for the new class will
-      # be written.
-      #
-      # @return [String] the path where the tests for the new class will be
-      # written.
-      def target_spec_path
-        @target_spec_path ||= begin
-          class_name_parts = object_name.split('::')
+      def template_files
+        # Calculate the class tests name
+        class_name_parts = object_name.split('::')
+        # Drop the module name if the object name contains multiple parts
+        class_name_parts.delete_at(0) if class_name_parts.length > 1
+        files = { 'class_spec.erb' => File.join('spec', 'classes', *class_name_parts) + '_spec.rb' }
+        return files if spec_only?
+
+        class_name_parts = object_name.split('::')[1..-1]
+        class_name_parts << 'init' if class_name_parts.empty?
+        files['class.erb'] = File.join('manifests', *class_name_parts) + '.pp'
 
-          # drop the module name if the object name contains multiple parts
-          class_name_parts.delete_at(0) if class_name_parts.length > 1
+        files
+      end
 
-          "#{File.join(module_dir, 'spec', 'classes', *class_name_parts)}_spec.rb"
-        end
+      def template_data
+        { name: object_name }
       end
     end
   end

data/lib/pdk/generate/puppet_object.rb

@@ -3,7 +3,7 @@ require 'pdk'
 module PDK
   module Generate
     class PuppetObject
-      attr_reader :module_dir
+      attr_reader :context
       attr_reader :object_name
       attr_reader :options
 
@@ -16,232 +16,128 @@ module PDK
       # OBJECT_TYPE constant and implement the {#template_data},
       # {#target_object_path} and {#target_spec_path} methods.
       #
-      # @param module_dir [String] The path to the module directory that the
+      # @param module_dir [String] The path to the root of module that the
       #   will contain the object.
       # @param object_name [String] The name of the object.
       # @param options [Hash{Symbol => Object}]
-      #
-      # @api public
-      def initialize(module_dir, object_name, options)
-        @module_dir = module_dir
+      def initialize(context, object_name, options)
+        raise ArgumentError, _('Expected PDK::Context::AbstractContext but got \'%{klass}\' for context') % { klass: context.class } unless context.is_a?(PDK::Context::AbstractContext)
+        @context = context
         @options = options
         @object_name = object_name
-
-        if [:class, :defined_type].include?(object_type) # rubocop:disable Style/GuardClause
-          object_name_parts = object_name.split('::')
-
-          @object_name = if object_name_parts.first == module_name
-                           object_name
-                         else
-                           [module_name, object_name].join('::')
-                         end
-        end
       end
 
+      # Whether the generator should only return test (spec) files
+      # @return [Boolean]
       def spec_only?
         @options[:spec_only]
       end
 
-      # @abstract Subclass and implement {#template_data} to provide data to
-      #   the templates during rendering. Implementations of this method should
-      #   return a Hash!{Symbol => Object}.
-      def template_data
+      # Subclass and implement {#friendly_name} to provide a nice name to show users in CLI
+      # @abstract
+      # @return String
+      def friendly_name
         raise NotImplementedError
       end
 
-      # @abstract Subclass and implement {#target_object_path}. Implementations
-      #   of this method should return a String containing the destination path
-      #   of the object being generated.
-      def target_object_path
+      # Subclass and implement {#template_files} to provide the template files to
+      #   render. Implementations of this method should return a Hash!{String => String}.
+      # @abstract
+      # @return Hash{String => String} Hash key is the source template file and the Hash value is
+      #                                the relative destination path
+      def template_files
         raise NotImplementedError
       end
 
-      # @abstract Subclass and implement {#target_type_path}. Implementations
-      #   of this method should return a String containing the destination path
-      #   of the additional object file being generated.
-      # @return [String] returns nil if there is no additional object file
-      def target_type_path
-        nil
-      end
-
-      # @abstract Subclass and implement {#target_spec_path}. Implementations
-      #   of this method should return a String containing the destination path
-      #   of the tests for the object being generated.
-      def target_spec_path
+      #  Subclass and implement {#template_data} to provide data to the templates during rendering.
+      # @abstract
+      # @return Hash{Symbol => Object}
+      def template_data
         raise NotImplementedError
       end
 
-      # @abstract Subclass and implement {#target_type_spec_path}. Implementations
-      #   of this method should return a String containing the destination path
-      #   of the tests for the object being generated.
-      def target_type_spec_path
-        nil
-      end
-
-      # @abstract Subclass and implement {#target_device_path}. Implementations
-      #   of this method should return a String containing the destination path
-      #   of the device class being generated.
-      def target_device_path
-        nil
-      end
-
-      # Retrieves the type of the object being generated, e.g. :class,
-      # :defined_type, etc. This is specified in the subclass' OBJECT_TYPE
-      # constant.
+      # Raises an error if any pre-conditions are not met
       #
-      # @return [Symbol] the type of the object being generated.
-      #
-      # @api private
-      def object_type
-        self.class::OBJECT_TYPE
+      # @return [void]
+      # @abstract
+      def check_preconditions
+        raise ArgumentError, _('Expected a module context but got %{context_name}') % { context_name: context.display_name } unless context.is_a?(PDK::Context::Module)
       end
 
-      # Retrieves the type of the object being generated as represented in
-      # the JSON output of puppet-strings.
+      # Check the preconditions of this template group, behaving as a predicate rather than raising an exception.
       #
-      # @return [String] the type of the object being generated or nil if
-      #   there is no mapping.
-      #
-      # @api private
-      def self.puppet_strings_type
-        return nil unless const_defined?(:PUPPET_STRINGS_TYPE)
-
-        self::PUPPET_STRINGS_TYPE
+      # @return [Boolean] true if the generator is safe to run, otherwise false.
+      def can_run?
+        check_preconditions
+        true
+      rescue StandardError
+        false
       end
 
-      # Returns an array of possible target path strings.
-      def targets
-        targets = [
-          target_spec_path,
-          target_type_spec_path,
-        ]
-
-        unless spec_only?
-          targets += [
-            target_object_path,
-            target_type_path,
-            target_device_path,
-          ]
-        end
-
-        targets.compact
+      # Creates an instance of an update manager
+      # @api private
+      def update_manager_instance
+        require 'pdk/module/update_manager'
+        PDK::Module::UpdateManager.new
       end
 
-      # Check preconditions of this template group. By default this only makes sure that the target files do not
-      # already exist. Override this (and call super) to add your own preconditions.
-      #
-      # @raise [PDK::CLI::ExitWithError] if the target files already exist.
+      # Stages and then executes the changes for the templates to be rendereed.
+      # This is the main entry point for the class.
       #
+      # @see #stage_changes
+      # @return [PDK::Module::UpdateManager] The update manager which implemented the changes
       # @api public
-      def check_preconditions
-        require 'pdk/util/filesystem'
-
-        targets.each do |target_file|
-          next unless PDK::Util::Filesystem.exist?(target_file)
-
-          raise PDK::CLI::ExitWithError, _("Unable to generate %{object_type}; '%{file}' already exists.") % {
-            file:        target_file,
-            object_type: spec_only? ? 'unit test' : object_type,
-          }
-        end
-      end
-
-      # Check the preconditions of this template group, behaving as a
-      # predicate rather than raising an exception.
-      #
-      # @return [Boolean] true if the generator is safe to run, otherwise
-      #   false.
-      def can_run?
-        check_preconditions
-        true
-      rescue PDK::CLI::ExitWithError
-        false
+      def run(update_manager = update_manager_instance)
+        stage_changes(update_manager).sync_changes!
+        update_manager
       end
 
       # Check that the templates can be rendered. Find an appropriate template
-      # and create the target files from the template. This is the main entry
+      # and stages the target files from the template. This is the main entry
       # point for the class.
       #
       # @raise [PDK::CLI::ExitWithError] if the target files already exist.
       # @raise [PDK::CLI::FatalError] (see #render_file)
-      #
+      # @return [PDK::Module::UpdateManager] The update manager with the staged changes
       # @api public
-      def run
+      def stage_changes(update_manager)
         check_preconditions
 
-        with_templates do |template_path, config_hash|
-          data = template_data.merge(configs: config_hash)
+        with_templates do |template_dir|
+          template_files.each do |source_file, relative_dest_path|
+            new_content = template_dir.render_single_item(source_file, template_data)
+            next if new_content.nil?
 
-          render_file(target_object_path, template_path[:object], data) unless spec_only?
-          render_file(target_type_path, template_path[:type], data) if template_path[:type]
-          render_file(target_device_path, template_path[:device], data) if template_path[:device]
-          render_file(target_spec_path, template_path[:spec], data) if template_path[:spec]
-          render_file(target_type_spec_path, template_path[:type_spec], data) if template_path[:type_spec]
+            stage_change(relative_dest_path, new_content, update_manager)
+          end
         end
+        non_template_files.each { |relative_dest_path, content| stage_change(relative_dest_path, content, update_manager) }
+
+        update_manager
       end
 
-      # Render a file using the provided template and write it to disk.
-      #
-      # @param dest_path [String] The path that the rendered file should be
-      #   written to. Any necessary directories will be automatically created.
-      # @param template_path [String] The path on disk to the file containing
-      #   the template.
-      # @param data [Hash{Object => Object}] The data to be provided to the
-      #   template when rendering.
-      #
-      # @raise [PDK::CLI::FatalError] if the parent directories to `dest_path`
-      #   do not exist and could not be created.
-      # @raise [PDK::CLI::FatalError] if the rendered file could not be written
-      #   to `dest_path`.
-      #
+      # Stages a single file into the Update Manager.
       # @return [void]
-      #
       # @api private
-      def render_file(dest_path, template_path, data)
-        require 'pdk/template_file'
-
-        write_file(dest_path) do
-          PDK::TemplateFile.new(template_path, data).render
+      def stage_change(relative_dest_path, content, update_manager)
+        absolute_file_path = File.join(context.root_path, relative_dest_path)
+        if PDK::Util::Filesystem.exist?(absolute_file_path)
+          raise PDK::CLI::ExitWithError, _("Unable to generate %{object_type}; '%{file}' already exists.") % {
+            file:        absolute_file_path,
+            object_type: spec_only? ? 'unit test' : friendly_name,
+          }
         end
+        update_manager.add_file(absolute_file_path, content)
       end
 
-      # Write the result of the block to disk.
-      #
-      # @param dest_path [String] The path that the rendered file should be
-      #   written to. Any necessary directories will be automatically created.
-      # @param &block [String] The content to be written
-      #
-      # @raise [PDK::CLI::FatalError] if the parent directories to `dest_path`
-      #   do not exist and could not be created.
-      # @raise [PDK::CLI::FatalError] if the rendered file could not be written
-      #   to `dest_path`.
-      #
-      # @return [void]
+      # A subclass may wish to stage files into the Update Manager, but the content is not templated. Subclasses
+      # can override this method to stage arbitrary files
       #
       # @api private
-      def write_file(dest_path)
-        require 'pdk/logger'
-        require 'pdk/util/filesystem'
-
-        PDK.logger.info(_("Creating '%{file}' from template.") % { file: dest_path })
-
-        file_content = yield
-
-        begin
-          PDK::Util::Filesystem.mkdir_p(File.dirname(dest_path))
-        rescue SystemCallError => e
-          raise PDK::CLI::FatalError, _("Unable to create directory '%{path}': %{message}") % {
-            path:    File.dirname(dest_path),
-            message: e.message,
-          }
-        end
-
-        PDK::Util::Filesystem.write_file(dest_path, file_content)
-      rescue SystemCallError => e
-        raise PDK::CLI::FatalError, _("Unable to write to file '%{path}': %{message}") % {
-          path:    dest_path,
-          message: e.message,
-        }
+      # @return [Hash{String => String}] A Hash with the relative file path as the key and the new file content as the value.
+      # @abstract
+      def non_template_files
+        {}
       end
 
       # Search the possible template directories in order of preference to find
@@ -260,7 +156,6 @@ module PDK
       # @api private
       def with_templates
         require 'pdk/logger'
-        require 'pdk/module/templatedir'
         require 'pdk/util/template_uri'
 
         templates.each do |template|
@@ -269,18 +164,15 @@ module PDK
             next
           end
 
-          PDK::Module::TemplateDir.new(PDK::Util::TemplateURI.new(template[:uri])) do |template_dir|
-            template_paths = template_dir.object_template_for(object_type)
-
-            if template_paths
-              config_hash = template_dir.object_config
-              yield template_paths, config_hash
+          PDK::Template.with(PDK::Util::TemplateURI.new(template[:uri]), context) do |template_dir|
+            if template_files.any? { |source_file, _| template_dir.has_single_item?(source_file) }
+              yield template_dir
               # TODO: refactor to a search-and-execute form instead
               return # work is done # rubocop:disable Lint/NonLocalExitFromIterator
             elsif template[:allow_fallback]
-              PDK.logger.debug(_('Unable to find a %{type} template in %{url}; trying next template directory.') % { type: object_type, url: template[:uri] })
+              PDK.logger.debug(_('Unable to find a %{type} template in %{url}; trying next template directory.') % { type: friendly_name, url: template[:uri] })
             else
-              raise PDK::CLI::FatalError, _('Unable to find the %{type} template in %{url}.') % { type: object_type, url: template[:uri] }
+              raise PDK::CLI::FatalError, _('Unable to find the %{type} template in %{url}.') % { type: friendly_name, url: template[:uri] }
             end
           end
         end
@@ -321,15 +213,18 @@ module PDK
       #
       # @api private
       def module_name
-        require 'pdk/util'
+        return nil unless context.is_a?(PDK::Context::Module)
 
-        @module_name ||= PDK::Util.module_metadata['name'].rpartition('-').last
+        require 'pdk/util'
+        @module_name ||= PDK::Util.module_metadata(context.root_path)['name'].rpartition('-').last
       rescue ArgumentError => e
         raise PDK::CLI::FatalError, e
       end
 
-      # transform a object name into a ruby class name
-      def self.class_name_from_object_name(object_name)
+      private
+
+      # Transform an object name into a ruby class name
+      def class_name_from_object_name(object_name)
         object_name.to_s.split('_').map(&:capitalize).join
       end
     end