pdk 1.15.0 → 2.0.0

data/lib/pdk/context/module.rb

@@ -0,0 +1,28 @@
+require 'pdk'
+
+module PDK
+  module Context
+    # Represents a context for a Puppet Module
+    class Module < PDK::Context::AbstractContext
+      # @param module_root [String] The root path for the module.
+      # @param context_path [String] The path where this context was created from e.g. Dir.pwd
+      # @see PDK::Context::AbstractContext
+      def initialize(module_root, context_path)
+        super(context_path)
+        @root_path = module_root
+      end
+
+      # @see PDK::Context::AbstractContext.pdk_compatible?
+      def pdk_compatible?
+        PDK::Util.module_pdk_compatible?(root_path)
+      end
+
+      #:nocov:
+      # @see PDK::Context::AbstractContext.display_name
+      def display_name
+        _('a Puppet Module context')
+      end
+      #:nocov:
+    end
+  end
+end

data/lib/pdk/context/none.rb

@@ -0,0 +1,22 @@
+require 'pdk'
+
+module PDK
+  module Context
+    # Represents a context which the PDK does not know. For example
+    # an empty directory
+    class None < PDK::Context::AbstractContext
+      #:nocov:
+      # @see PDK::Context::AbstractContext.display_name
+      def display_name
+        _('an unknown context')
+      end
+      #:nocov:
+
+      # @see PDK::Context::AbstractContext.parent_context
+      def parent_context
+        # An unknown context has no parent
+        nil
+      end
+    end
+  end
+end

data/lib/pdk/control_repo.rb

@@ -0,0 +1,90 @@
+require 'pdk'
+
+module PDK
+  module ControlRepo
+    CONTROL_REPO_FILES = %w[environment.conf Puppetfile].freeze
+
+    DEFAULT_IGNORED = [
+      '/pkg/',
+      '~*',
+      '/coverage',
+      # Strictly speaking this isn't default but if people have tricked older PDK into thinking that a
+      # Control Repo is a module, they may have recursive symlinks in spec/fixtures/modules
+      '/spec/fixtures/modules/',
+      '/vendor/',
+    ].freeze
+
+    # Returns path to the root of the Control Repo being worked on.
+    #
+    # An environment.conf is required for a PDK compatible Control Repo,
+    # whereas Puppetfile is optional.
+    #
+    # Note - A Bolt Project can also be a Control Repo.
+    #
+    # Note - Non-Directory environments can exist however directory based
+    # environments are the supported/preferred way.
+    #
+    # @see https://puppet.com/docs/pe/latest/control_repo.html
+    #
+    # @param strict_check [Boolean] When strict_check is true, only return the path
+    #   if the Control Repo is strictly _only_ a control repository. For example,
+    #   not also a Puppet Bolt project directory  Default is false.
+    #
+    # @return [String, nil] Fully qualified base path to Control Repo, or nil if
+    #   the current working dir does not appear to be within a Control Repo.
+    def find_control_repo_root(strict_check = false)
+      environment_conf_path = PDK::Util.find_upwards('environment.conf')
+      path = if environment_conf_path
+               File.dirname(environment_conf_path)
+             elsif control_repo_root?(Dir.pwd)
+               Dir.pwd
+             else
+               nil
+             end
+      return path if path.nil? || !strict_check
+      PDK::Bolt.bolt_project_root?(path) ? nil : path
+    end
+    module_function :find_control_repo_root
+
+    # Returns true or false depending on if any of the common files in a Control Repo
+    # are found in the specified directory. If a directory is not specified, the current
+    # working directory is used.
+    #
+    # @return [boolean] True if any folders from CONTROL_REPO_FILES are found in the current dir,
+    #   false otherwise.
+    def control_repo_root?(path = Dir.pwd)
+      CONTROL_REPO_FILES.any? { |file| PDK::Util::Filesystem.file?(File.join(path, file)) }
+    end
+    module_function :control_repo_root?
+
+    # Returns a PDK::Config::Namespace for the specified environment.conf file.
+    # Note there is no validation of the path.
+    #
+    # @param path [String] The path to the environment.conf file
+    #
+    # @return [PDK::Config::IniFile] The configuration file
+    def environment_conf_as_config(path)
+      PDK::Config::IniFile.new('environment', file: path) do
+        setting :modulepath do
+          # As per https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+          default_to { 'modules:$basemodulepath' }
+        end
+
+        setting :manifest do
+          # As per https://puppet.com/docs/puppet/latest/config_file_environment.html#allowed-settings
+          default_to { 'manifests/' }
+        end
+      end
+    end
+    module_function :environment_conf_as_config
+
+    def default_ignored_pathspec(ignore_dotfiles = true)
+      require 'pathspec'
+
+      PathSpec.new(DEFAULT_IGNORED).tap do |ps|
+        ps.add('.*') if ignore_dotfiles
+      end
+    end
+    module_function :default_ignored_pathspec
+  end
+end

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/fact.rb

@@ -0,0 +1,25 @@
+require 'pdk'
+
+module PDK
+  module Generate
+    class Fact < PuppetObject
+      def friendly_name
+        'Custom Fact'.freeze
+      end
+
+      def template_files
+        files = {
+          'fact_spec.erb' => File.join('spec', 'unit', 'facter', object_name) + '_spec.rb',
+        }
+        return files if spec_only?
+        files.merge(
+          'fact.erb' => File.join('lib', 'facter', object_name) + '.rb',
+        )
+      end
+
+      def template_data
+        { name: object_name }
+      end
+    end
+  end
+end

data/lib/pdk/generate/function.rb

@@ -0,0 +1,48 @@
+require 'pdk'
+
+module PDK
+  module Generate
+    class Function < PuppetObject
+      def initialize(*_args)
+        super
+        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
+
+      def friendly_name
+        'Function'.freeze
+      end
+
+      def template_files
+        # Calculate the function tests name
+        func_name_parts = object_name.split('::')
+        # Drop the module name if the object name contains multiple parts
+        func_name_parts.delete_at(0) if func_name_parts.length > 1
+        files = {
+          File.join('functions', 'function_spec.erb') => File.join('spec', 'functions', *func_name_parts) + '_spec.rb',
+        }
+        return files if spec_only?
+        func_name_parts = object_name.split('::')[1..-1]
+        template_file = File.join('functions', "#{options[:type]}_function.erb")
+
+        files[template_file] = if options[:type].eql?('v4')
+                                 File.join('lib', 'puppet', 'functions', module_name, *func_name_parts) + '.rb'
+                               else
+                                 File.join('functions', *func_name_parts) + '.pp'
+                               end
+        files
+      end
+
+      def template_data
+        func_name = object_name.split('::').last
+        namespace = object_name.split('::')[0...-1].join('::')
+        { name: object_name, func_name: func_name, namespace: namespace }
+      end
+    end
+  end
+end

data/lib/pdk/generate/module.rb

@@ -46,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.with(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
               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
@@ -67,15 +79,15 @@ 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
@@ -87,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.bare_uri }
-            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}") % {
@@ -119,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)
@@ -326,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

@@ -3,74 +3,25 @@ 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'
+      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