pdk 1.9.0 → 3.2.0

data/lib/pdk/generate/module.rb

@@ -1,72 +1,68 @@
-require 'etc'
-require 'pathname'
-require 'fileutils'
-require 'tty-prompt'
-
 require 'pdk'
-require 'pdk/logger'
-require 'pdk/module/metadata'
-require 'pdk/module/templatedir'
-require 'pdk/cli/exec'
-require 'pdk/cli/util'
-require 'pdk/cli/util/interview'
-require 'pdk/cli/util/option_validator'
-require 'pdk/util'
-require 'pdk/util/version'
 
 module PDK
   module Generate
     class Module
-      extend PDK::Util::Filesystem
+      def self.validate_options(opts = {})
+        require 'pdk/cli/util/option_validator'
 
-      def self.validate_options(opts)
         unless PDK::CLI::Util::OptionValidator.valid_module_name?(opts[:module_name])
-          error_msg = _(
-            "'%{module_name}' is not a valid module name.\n" \
-            'Module names must begin with a lowercase letter and can only include lowercase letters, digits, and underscores.',
-          ) % { module_name: opts[:module_name] }
+          error_msg = format("'%{module_name}' is not a valid module name.\n" \
+                             'Module names must begin with a lowercase letter and can only include lowercase letters, digits, and underscores.', module_name: opts[:module_name])
           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, format("The destination directory '%{dir}' already exists", dir: target_dir) if PDK::Util::Filesystem.exist?(target_dir)
       end
 
       def self.invoke(opts = {})
+        require 'pdk/util'
+        require 'pdk/util/template_uri'
+        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)
-        rescue Errno::EACCES
-          raise PDK::CLI::FatalError, _("You do not have permission to write to '%{parent_dir}'") % {
-            parent_dir: parent_dir,
-          }
+          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 || Errno::EROFS
+          raise PDK::CLI::FatalError, format("You do not have permission to write to '%{parent_dir}'", parent_dir: parent_dir)
         end
 
         temp_target_dir = PDK::Util.make_tmpdir_name('pdk-module-target')
 
         prepare_module_directory(temp_target_dir)
 
-        template_url = opts.fetch(:'template-url', PDK::Util.default_template_url)
+        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 format("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_url, metadata.data, true) do |templates|
-            templates.render do |file_path, file_content|
-              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
@@ -74,58 +70,71 @@ module PDK
           raise PDK::CLI::ExitWithError, e
         end
 
-        if template_url == PDK::Util.puppetlabs_template_url
-          # If the user specifies our template via the command line, remove the
-          # saved template-url answer.
-          PDK.answers.update!('template-url' => nil) if opts.key?(:'template-url')
+        # Only update the answers files after metadata has been written.
+        require 'pdk/answer_file'
+        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.config.set(['user', 'module_defaults', 'template-url'], nil) if opts.key?(:'template-url')
         else
-          # Save the template-url answer if the module was generated using
-          # a template other than ours.
-          PDK.answers.update!('template-url' => template_url)
+          # Save the template-url answers if the module was generated using a
+          # template/reference other than ours.
+          PDK.config.set(['user', 'module_defaults', 'template-url'], template_uri.metadata_format)
         end
 
         begin
-          if FileUtils.mv(temp_target_dir, target_dir)
-            Dir.chdir(target_dir) { PDK::Util::Bundler.ensure_bundle! } unless opts[:'skip-bundle-install']
+          if PDK::Util::Filesystem.mv(temp_target_dir, target_dir)
+            unless opts[:'skip-bundle-install']
+              Dir.chdir(target_dir) do
+                require 'pdk/util/bundler'
+                PDK::Util::Bundler.ensure_bundle!
+              end
+            end
 
-            PDK.logger.info(_('Module \'%{name}\' generated at path \'%{path}\', from template \'%{template_url}\'.') % { name: opts[:module_name], path: target_dir, template_url: template_url })
-            PDK.logger.info(_('In your module directory, add classes with the \'pdk new class\' command.'))
+            PDK.logger.info format("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}") % {
-            source:  temp_target_dir,
-            target:  target_dir,
-            message: e.message,
-          }
+          raise PDK::CLI::FatalError, format("Failed to move '%{source}' to '%{target}': %{message}", source: temp_target_dir, target: target_dir, message: e.message)
         end
       end
 
       def self.username_from_login
+        require 'etc'
+
         login = Etc.getlogin || ''
-        login_clean = login.downcase.gsub(%r{[^0-9a-z]}i, '')
+        login_clean = login.downcase.gsub(/[^0-9a-z]/i, '')
         login_clean = 'username' if login_clean.empty?
 
         if login_clean != login
-          PDK.logger.debug _('Your username is not a valid Forge username. Proceeding with the username %{username}. You can fix this later in metadata.json.') % {
-            username: login_clean,
-          }
+          PDK.logger.debug format('Your username is not a valid Forge username. Proceeding with the username %{username}. You can fix this later in metadata.json.', username: login_clean)
         end
 
         login_clean
       end
 
       def self.prepare_metadata(opts = {})
-        opts[:username] = (opts[:username] || PDK.answers['forge_username'] || username_from_login).downcase
+        require 'pdk/answer_file'
+        require 'pdk/module/metadata'
+
+        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?
-        defaults['license'] = opts[:license] if opts.key? :license
+        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)
+        PDK.config.with_scoped_value('module_defaults.operatingsystem_support') { |val| defaults['operatingsystem_support'] = val }
 
         metadata = PDK::Module::Metadata.new(defaults)
-        module_interview(metadata, opts) unless opts[:'skip-interview']
+
+        if opts[:'skip-interview']
+          metadata.data['operatingsystem_support'] = metadata.data['operatingsystem_support'].map { |val| PDK::Module::Metadata::OPERATING_SYSTEMS[val] }.flatten
+        else
+          module_interview(metadata, opts)
+        end
 
         metadata
       end
@@ -136,103 +145,102 @@ module PDK
           File.join(target_dir, 'files'),
           File.join(target_dir, 'manifests'),
           File.join(target_dir, 'templates'),
-          File.join(target_dir, 'tasks'),
+          File.join(target_dir, 'tasks')
         ].each do |dir|
-          begin
-            FileUtils.mkdir_p(dir)
-          rescue SystemCallError => e
-            raise PDK::CLI::FatalError, _("Unable to create directory '%{dir}': %{message}") % {
-              dir:     dir,
-              message: e.message,
-            }
-          end
+          PDK::Util::Filesystem.mkdir_p(dir)
+        rescue SystemCallError => e
+          raise PDK::CLI::FatalError, format("Unable to create directory '%{dir}': %{message}", dir: dir, message: e.message)
         end
       end
 
       def self.module_interview(metadata, opts = {})
+        require 'pdk/module/metadata'
+        require 'pdk/cli/util/interview'
+
         questions = [
           {
-            name:             'module_name',
-            question:         _('If you have a name for your module, add it here.'),
-            help:             _('This is the name that will be associated with your module, it should be relevant to the modules content.'),
-            required:         true,
-            validate_pattern: %r{\A[a-z][a-z0-9_]*\Z}i,
-            validate_message: _('Module names must begin with a lowercase letter and can only include lowercase letters, numbers, and underscores.'),
+            name: 'module_name',
+            question: 'If you have a name for your module, add it here.',
+            help: 'This is the name that will be associated with your module, it should be relevant to the modules content.',
+            required: true,
+            validate_pattern: /\A[a-z][a-z0-9_]*\Z/i,
+            validate_message: 'Module names must begin with a lowercase letter and can only include lowercase letters, numbers, and underscores.'
           },
           {
-            name:             'forge_username',
-            question:         _('If you have a Puppet Forge username, add it here.'),
-            help:             _('We can use this to upload your module to the Forge when it\'s complete.'),
-            required:         true,
-            validate_pattern: %r{\A[a-z0-9]+\Z}i,
-            validate_message: _('Forge usernames can only contain lowercase letters and numbers'),
-            default:          opts[:username],
+            name: 'forge_username',
+            question: 'If you have a Puppet Forge username, add it here.',
+            help: 'We can use this to upload your module to the Forge when it\'s complete.',
+            required: true,
+            validate_pattern: /\A[a-z0-9]+\Z/i,
+            validate_message: 'Forge usernames can only contain lowercase letters and numbers',
+            default: opts[:username]
           },
           {
-            name:             'version',
-            question:         _('What version is this module?'),
-            help:             _('Puppet uses Semantic Versioning (semver.org) to version modules.'),
-            required:         true,
-            validate_pattern: %r{\A[0-9]+\.[0-9]+\.[0-9]+},
-            validate_message: _('Semantic Version numbers must be in the form MAJOR.MINOR.PATCH'),
-            default:          metadata.data['version'],
-            forge_only:       true,
+            name: 'version',
+            question: 'What version is this module?',
+            help: 'Puppet uses Semantic Versioning (semver.org) to version modules.',
+            required: true,
+            validate_pattern: /\A[0-9]+\.[0-9]+\.[0-9]+/i,
+            validate_message: 'Semantic Version numbers must be in the form MAJOR.MINOR.PATCH',
+            default: metadata.data['version'],
+            forge_only: true
           },
           {
-            name:     'author',
-            question: _('Who wrote this module?'),
-            help:     _('This is used to credit the module\'s author.'),
+            name: 'author',
+            question: 'Who wrote this module?',
+            help: 'This is used to credit the module\'s author.',
             required: true,
-            default:  metadata.data['author'],
+            default: metadata.data['author']
           },
           {
-            name:     'license',
-            question: _('What license does this module code fall under?'),
-            help:     _('This should be an identifier from https://spdx.org/licenses/. Common values are "Apache-2.0", "MIT", or "proprietary".'),
+            name: 'license',
+            question: 'What license does this module code fall under?',
+            help: 'This should be an identifier from https://spdx.org/licenses/. Common values are "Apache-2.0", "MIT", or "proprietary".',
             required: true,
-            default:  metadata.data['license'],
+            default: metadata.data['license']
           },
           {
-            name:     'operatingsystem_support',
-            question: _('What operating systems does this module support?'),
-            help:     _('Use the up and down keys to move between the choices, space to select and enter to continue.'),
+            name: 'operatingsystem_support',
+            question: 'What operating systems does this module support?',
+            help: 'Use the up and down keys to move between the choices, space to select and enter to continue.',
             required: true,
-            choices:  PDK::Module::Metadata::OPERATING_SYSTEMS,
-            default:  PDK::Module::Metadata::DEFAULT_OPERATING_SYSTEMS.map do |os_name|
+            type: :multi_select,
+            choices: PDK::Module::Metadata::OPERATING_SYSTEMS,
+            default: metadata.data['operatingsystem_support'] do |os_name|
               # tty-prompt uses a 1-index
               PDK::Module::Metadata::OPERATING_SYSTEMS.keys.index(os_name) + 1
-            end,
+            end
           },
           {
-            name:       'summary',
-            question:   _('Summarize the purpose of this module in a single sentence.'),
-            help:       _('This helps other Puppet users understand what the module does.'),
-            required:   true,
-            default:    metadata.data['summary'],
-            forge_only: true,
+            name: 'summary',
+            question: 'Summarize the purpose of this module in a single sentence.',
+            help: 'This helps other Puppet users understand what the module does.',
+            required: true,
+            default: metadata.data['summary'],
+            forge_only: true
           },
           {
-            name:       'source',
-            question:   _('If there is a source code repository for this module, enter the URL here.'),
-            help:       _('Skip this if no repository exists yet. You can update this later in the metadata.json.'),
-            required:   true,
-            default:    metadata.data['source'],
-            forge_only: true,
+            name: 'source',
+            question: 'If there is a source code repository for this module, enter the URL here.',
+            help: 'Skip this if no repository exists yet. You can update this later in the metadata.json.',
+            required: true,
+            default: metadata.data['source'],
+            forge_only: true
           },
           {
-            name:       'project_page',
-            question:   _('If there is a URL where others can learn more about this module, enter it here.'),
-            help:       _('Optional. You can update this later in the metadata.json.'),
-            default:    metadata.data['project_page'],
-            forge_only: true,
+            name: 'project_page',
+            question: 'If there is a URL where others can learn more about this module, enter it here.',
+            help: 'Optional. You can update this later in the metadata.json.',
+            default: metadata.data['project_page'],
+            forge_only: true
           },
           {
-            name:       'issues_url',
-            question:   _('If there is a public issue tracker for this module, enter its URL here.'),
-            help:       _('Optional. You can update this later in the metadata.json.'),
-            default:    metadata.data['issues_url'],
-            forge_only: true,
-          },
+            name: 'issues_url',
+            question: 'If there is a public issue tracker for this module, enter its URL here.',
+            help: 'Optional. You can update this later in the metadata.json.',
+            default: metadata.data['issues_url'],
+            forge_only: true
+          }
         ]
 
         prompt = TTY::Prompt.new(help_color: :cyan)
@@ -241,8 +249,8 @@ module PDK
 
         if opts[:only_ask]
           questions.reject! do |question|
-            if %w[module_name forge_username].include?(question[:name])
-              metadata.data['name'] && metadata.data['name'] =~ %r{\A[a-z0-9]+-[a-z][a-z0-9_]*\Z}i
+            if ['module_name', 'forge_username'].include?(question[:name])
+              metadata.data['name'] && metadata.data['name'] =~ /\A[a-z0-9]+-[a-z][a-z0-9_]*\Z/i
             else
               !opts[:only_ask].include?(question[:name])
             end
@@ -250,27 +258,27 @@ module PDK
         else
           questions.reject! { |q| q[:name] == 'module_name' } if opts.key?(:module_name)
           questions.reject! { |q| q[:name] == 'license' } if opts.key?(:license)
-          questions.reject! { |q| q[:forge_only] } unless opts.key?(:'full-interview')
+          questions.reject! { |q| q[:forge_only] } unless opts[:'full-interview']
         end
 
         interview.add_questions(questions)
 
-        action = File.file?('metadata.json') ? _('update') : _('create')
-        puts _(
-          "\nWe need to %{action} the metadata.json file for this module, so we\'re going to ask you %{count} " \
-          "questions.\n" \
-          'If the question is not applicable to this module, accept the default option ' \
-          'shown after each question. You can modify any answers at any time by manually updating ' \
-          "the metadata.json file.\n\n",
-        ) % {
-          count: interview.num_questions,
-          action: action,
-        }
+        if PDK::Util::Filesystem.file?('metadata.json')
+          puts format("\nWe need to update the metadata.json file for this module, so we're going to ask you %{count} " \
+                      "questions.\n", count: interview.num_questions)
+        else
+          puts format("\nWe need to create the metadata.json file for this module, so we're going to ask you %{count} " \
+                      "questions.\n", count: interview.num_questions)
+        end
+
+        puts 'If the question is not applicable to this module, accept the default option ' \
+             'shown after each question. You can modify any answers at any time by manually updating ' \
+             "the metadata.json file.\n\n"
 
         answers = interview.run
 
         if answers.nil?
-          PDK.logger.info _('No answers given, interview cancelled.')
+          PDK.logger.info 'No answers given, interview cancelled.'
           exit 0
         end
 
@@ -293,25 +301,24 @@ module PDK
         metadata.update!(answers)
 
         if opts[:prompt].nil? || opts[:prompt]
+          require 'pdk/cli/util'
+
           continue = PDK::CLI::Util.prompt_for_yes(
-            _('Metadata will be generated based on this information, continue?'),
-            prompt:         prompt,
-            cancel_message: _('Interview cancelled; exiting.'),
+            'Metadata will be generated based on this information, continue?',
+            prompt: prompt,
+            cancel_message: 'Interview cancelled; exiting.'
           )
 
           unless continue
-            PDK.logger.info _('Process cancelled; exiting.')
+            PDK.logger.info 'Process cancelled; exiting.'
             exit 0
           end
         end
 
-        PDK.answers.update!(
-          {
-            'forge_username' => opts[:username],
-            'author'         => answers['author'],
-            'license'        => answers['license'],
-          }.delete_if { |_key, value| value.nil? },
-        )
+        require 'pdk/answer_file'
+        PDK.config.set(['user', 'module_defaults', 'forge_username'], opts[:username]) unless opts[:username].nil?
+        PDK.config.set(['user', 'module_defaults', 'author'], answers['author']) unless answers['author'].nil?
+        PDK.config.set(['user', 'module_defaults', 'license'], answers['license']) unless answers['license'].nil?
       end
     end
   end

data/lib/pdk/generate/provider.rb

@@ -1,81 +1,28 @@
-require 'pdk/generate/puppet_object'
+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://github.com/puppetlabs/puppet-resource_api#getting-started.') % { 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
+      def friendly_name
+        'Resource API Provider'.freeze
       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'
-      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'
-      end
+      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?
 
-      # @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'
+        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
 
-      # transform a object name into a ruby class name
-      def self.class_name_from_object_name(object_name)
-        object_name.to_s.split('_').map(&:capitalize).join
+      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

@@ -1,47 +1,42 @@
-require 'pdk/generate/puppet_object'
+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..]
+        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