pdk 1.14.1 → 1.18.1

data/lib/pdk/template/renderer/v1/renderer.rb

@@ -0,0 +1,132 @@
+require 'pdk'
+require 'pdk/template/renderer'
+
+module PDK
+  module Template
+    module Renderer
+      module V1
+        class Renderer < PDK::Template::Renderer::AbstractRenderer
+          # @see PDK::Template::Renderer::AbstractRenderer.render
+          def render(template_type, _name, options = {})
+            render_module(options) { |*args| yield(*args) } if template_type == PDK::Template::MODULE_TEMPLATE_TYPE
+          end
+
+          # @see PDK::Template::Renderer::AbstractRenderer.has_single_item?
+          def has_single_item?(item_path) # rubocop:disable Naming/PredicateName
+            PDK::Util::Filesystem.exist?(single_item_path(item_path))
+          end
+
+          # @see PDK::Template::Renderer::AbstractRenderer.render_single_item
+          def render_single_item(relative_file_path, template_data_hash)
+            template_file = single_item_path(relative_file_path)
+            return nil unless PDK::Util::Filesystem.file?(template_file) && PDK::Util::Filesystem.readable?(template_file)
+
+            PDK.logger.debug(_("Rendering '%{template}'...") % { template: template_file })
+            new_template_file(template_file, template_data_hash).render
+          end
+
+          # Returns the full path for a single item
+          #
+          # @param item_path [String] The path of the single item to render
+          # @return [String]
+          # @api private
+          #:nocov:
+          def single_item_path(item_path)
+            File.join(template_root, 'object_templates', item_path)
+          end
+          #:nocov:
+
+          # Helper method used during testing
+          #:nocov:
+          # @api private
+          def new_template_file(template_file, template_data_hash)
+            TemplateFile.new(template_file, template_data_hash)
+          end
+          #:nocov:
+
+          # Helper method used during testing
+          #:nocov:
+          # @api private
+          def new_legacy_template_dir(context, uri, path, module_metadata = {})
+            LegacyTemplateDir.new(context, uri, path, module_metadata)
+          end
+          #:nocov:
+
+          # Renders a new module
+          #
+          # @param options [Hash{Object => Object}] A list of options to pass through to the renderer. See PDK::Template::TemplateDir helper methods for other options
+          # @see #render
+          # @api private
+          #:nocov: This is tested in acceptance and packaging tests
+          def render_module(options = {})
+            require 'pdk/template/renderer/v1/template_file'
+
+            moduleroot_dir = File.join(template_root, 'moduleroot')
+            moduleroot_init = File.join(template_root, 'moduleroot_init')
+
+            dirs = [moduleroot_dir]
+            dirs << moduleroot_init if options[:include_first_time]
+
+            legacy_template_dir = new_legacy_template_dir(context, template_uri, template_root, options[:module_metadata] || {})
+
+            files_in_template(dirs).each do |template_file, template_loc|
+              template_file = template_file.to_s
+              PDK.logger.debug(_("Rendering '%{template}'...") % { template: template_file })
+              dest_path = template_file.sub(%r{\.erb\Z}, '')
+              config = legacy_template_dir.config_for(dest_path)
+
+              dest_status = if template_loc.start_with?(moduleroot_init)
+                              :init
+                            else
+                              :manage
+                            end
+
+              if config['unmanaged']
+                dest_status = :unmanage
+              elsif config['delete']
+                dest_status = :delete
+              else
+                begin
+                  dest_content = new_template_file(File.join(template_loc, template_file), configs: config, template_dir: legacy_template_dir).render
+                rescue => error
+                  error_msg = _(
+                    "Failed to render template '%{template}'\n" \
+                    '%{exception}: %{message}',
+                  ) % { template: template_file, exception: error.class, message: error.message }
+                  raise PDK::CLI::FatalError, error_msg
+                end
+              end
+
+              yield dest_path, dest_content, dest_status
+            end
+          end
+          #:nocov:
+
+          # Returns all files in the given template directories
+          #
+          # @param dirs [Array[String]] Directories to search in
+          # @param glob_suffix [Array[String]] File glob to use when searching for files. Defaults to ['**', '*']
+          #
+          # @return [Hash{String => String}] Key is the template file relative path and the value is the absolute path to the template directory
+          # @api private
+          def files_in_template(dirs, glob_suffix = ['**', '*'])
+            temp_paths = []
+            dirlocs = []
+            dirs.each do |dir|
+              raise ArgumentError, _("The directory '%{dir}' doesn't exist") % { dir: dir } unless PDK::Util::Filesystem.directory?(dir)
+              temp_paths += PDK::Util::Filesystem.glob(File.join(dir, *glob_suffix), File::FNM_DOTMATCH).select do |template_path|
+                if PDK::Util::Filesystem.file?(template_path) && !PDK::Util::Filesystem.symlink?(template_path)
+                  dirlocs << dir
+                end
+              end
+              temp_paths.map do |template_path|
+                template_path.sub!(%r{\A#{Regexp.escape(dir)}#{Regexp.escape(File::SEPARATOR)}}, '')
+              end
+            end
+            Hash[temp_paths.zip dirlocs]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/template/renderer/v1/template_file.rb

@@ -0,0 +1,102 @@
+require 'pdk'
+require 'ostruct'
+
+module PDK
+  module Template
+    module Renderer
+      module V1
+        class TemplateFile < OpenStruct
+          # Initialises the TemplateFile object with the path to the template file
+          # and the data to be used when rendering the template.
+          #
+          # @param template_file [String] The path on disk to the template file.
+          # @param data [Hash{Symbol => Object}] The data that should be provided to
+          # the template when rendering.
+          # @option data [Object] :configs The value of this key will be provided to
+          # the template as an instance variable `@configs` in order to maintain
+          # compatibility with modulesync.
+          #
+          # @api public
+          def initialize(template_file, data = {})
+            @template_file = template_file
+
+            if data.key?(:configs)
+              @configs = data[:configs]
+            end
+
+            super(data)
+          end
+
+          # Renders the template by calling the appropriate engine based on the file
+          # extension.
+          #
+          # If the template has an `.erb` extension, the content of the template
+          # file will be treated as an ERB template. All other extensions are treated
+          # as plain text.
+          #
+          # @return [String] The rendered template
+          #
+          # @raise (see #template_content)
+          #
+          # @api public
+          def render
+            case File.extname(@template_file)
+            when '.erb'
+              render_erb
+            else
+              render_plain
+            end
+          end
+
+          def config_for(path)
+            return unless respond_to?(:template_dir)
+
+            template_dir.config_for(path)
+          end
+
+          private
+
+          # Reads the content of the template file into memory.
+          #
+          # @return [String] The content of the template file.
+          #
+          # @raise [ArgumentError] If the template file does not exist or can not be
+          # read.
+          #
+          # @api private
+          def template_content
+            if PDK::Util::Filesystem.file?(@template_file) && PDK::Util::Filesystem.readable?(@template_file)
+              return PDK::Util::Filesystem.read_file(@template_file)
+            end
+
+            raise ArgumentError, _("'%{template}' is not a readable file") % { template: @template_file }
+          end
+
+          # Renders the content of the template file as an ERB template.
+          #
+          # @return [String] The rendered template.
+          #
+          # @raise (see #template_content)
+          #
+          # @api private
+          def render_erb
+            renderer = ERB.new(template_content, nil, '-')
+            renderer.filename = @template_file
+            renderer.result(binding)
+          end
+
+          # Renders the content of the template file as plain text.
+          #
+          # @return [String] The rendered template.
+          #
+          # @raise (see #template_content)
+          #
+          # @api private
+          def render_plain
+            template_content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdk/template/template_dir.rb

@@ -0,0 +1,67 @@
+require 'pdk'
+require 'forwardable'
+
+module PDK
+  module Template
+    # A helper class representing an already fetched template on disk, with an appropriate renderer instance.
+    # @see PDK::Template.with
+    class TemplateDir
+      # Creates an instance of TemplateDir object
+      # @see TemplateDir.new
+      def self.instance(uri, path, context, renderer = nil)
+        new(uri, path, context, renderer)
+      end
+
+      extend Forwardable
+
+      # Helper methods for rendering
+      def_delegators :@renderer, :render, :render_single_item, :has_single_item?
+
+      # @return [PDK::Util::TemplateURI] The URI which points to the source location of the Template
+      attr_accessor :uri
+
+      # @return [String] The path to where the template exists on disk
+      attr_accessor :path
+
+      # @return [Hash{String => String}] A hash of information about the template
+      attr_accessor :metadata
+
+      # @param template_uri [PDK::Util::TemplateUri] A URI which points to the source location of the Template
+      # @param path [String] The path to where the template exists on disk
+      # @param context [PDK::Context] The context in which the redering will occur in
+      # @param renderer [PDK::Template::Renderer::AbstractRenderer] The an instance of a rendering class. If nil, a renderer will be created that's appropriate for the template and context
+      def initialize(uri, path, context, renderer = nil)
+        @uri = uri
+        @path = path
+        @metadata = {}
+
+        @renderer = renderer.nil? ? Renderer.instance(uri, path, context) : renderer
+        raise _('Could not find a compatible template renderer for %{path}') % { path: path } if @renderer.nil?
+      end
+
+      # Later additions may include Control Repo rendering, for example
+      #
+      # def render_control_repo(name, options = {})
+      #   render(CONTROL_REPO_TEMPLATE_TYPE, name, options.merge(include_first_time: false)) { |*args| yield(*args) }
+      # end
+      #
+      # def render_new_control_repo(name, repo_metadata = {}, options = {})
+      #   render(CONTROL_REPO_TEMPLATE_TYPE, name, options.merge(include_first_time: true, control_repo_metadata: repo_metadata)) { |*args| yield(*args) }
+      # end
+      #:nocov: These are just helper methods and are tested elsewhere.
+
+      # Render an existing module
+      # @see PDK::Template::Renderer::AbstractRenderer.render
+      def render_module(module_name, options = {})
+        @renderer.render(MODULE_TEMPLATE_TYPE, module_name, options.merge(include_first_time: false)) { |*args| yield(*args) }
+      end
+
+      # Render a new module
+      # @see PDK::Template::Renderer::AbstractRenderer.render
+      def render_new_module(module_name, module_metadata = {}, options = {})
+        @renderer.render(MODULE_TEMPLATE_TYPE, module_name, options.merge(include_first_time: true, module_metadata: module_metadata)) { |*args| yield(*args) }
+      end
+      #:nocov:
+    end
+  end
+end

data/lib/pdk/tests/unit.rb

@@ -89,6 +89,11 @@ module PDK
         setup
 
         tests = options[:tests]
+        # Due to how rake handles paths in the command line options, any backslashed path (Windows platforms) needs to be converted
+        # to forward slash. We can't use File.expand_path as the files aren't guaranteed to be on-disk
+        #
+        # Ref - https://github.com/puppetlabs/pdk/issues/828
+        tests = tests.tr('\\', '/') unless tests.nil?
 
         environment = { 'CI_SPEC_OPTIONS' => '--format j' }
         environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]

data/lib/pdk/util.rb

@@ -10,9 +10,11 @@ autoload :Pathname, 'pathname'
 module PDK
   module Util
     autoload :Bundler, 'pdk/util/bundler'
+    autoload :ChangelogGenerator, 'pdk/util/changelog_generator'
     autoload :Env, 'pdk/util/env'
     autoload :Filesystem, 'pdk/util/filesystem'
     autoload :Git, 'pdk/util/git'
+    autoload :JSONFinder, 'pdk/util/json_finder'
     autoload :PuppetStrings, 'pdk/util/puppet_strings'
     autoload :PuppetVersion, 'pdk/util/puppet_version'
     autoload :RubyVersion, 'pdk/util/ruby_version'
@@ -31,6 +33,16 @@ module PDK
       types
     ].freeze
 
+    #:nocov:
+    # This method just wraps core Ruby functionality and
+    # can be ignored for code coverage
+
+    # Calls Kernel.exit with an exitcode
+    def exit_process(exit_code)
+      exit exit_code
+    end
+    #:nocov:
+
     # Searches upwards from current working directory for the given target file.
     #
     # @param target [String] Name of file to search for.
@@ -40,13 +52,13 @@ module PDK
     #   nil if the target file could not be found.
     def find_upwards(target, start_dir = nil)
       previous = nil
-      current  = File.expand_path(start_dir || Dir.pwd)
+      current  = PDK::Util::Filesystem.expand_path(start_dir || Dir.pwd)
 
-      until !File.directory?(current) || current == previous
+      until !PDK::Util::Filesystem.directory?(current) || current == previous
         filename = File.join(current, target)
-        return filename if File.file?(filename)
+        return filename if PDK::Util::Filesystem.file?(filename)
         previous = current
-        current = File.expand_path('..', current)
+        current = PDK::Util::Filesystem.expand_path('..', current)
       end
     end
     module_function :find_upwards
@@ -72,12 +84,12 @@ module PDK
     # @return [String] Canonical path
     def canonical_path(path)
       if Gem.win_platform?
-        unless File.exist?(path)
+        unless PDK::Util::Filesystem.exist?(path)
           raise PDK::CLI::FatalError, _("Cannot resolve a full path to '%{path}', as it does not currently exist.") % { path: path }
         end
         PDK::Util::Windows::File.get_long_pathname(path)
       else
-        File.expand_path(path)
+        PDK::Util::Filesystem.expand_path(path)
       end
     end
     module_function :canonical_path
@@ -135,6 +147,15 @@ module PDK
     end
     module_function :configdir
 
+    def system_configdir
+      return @system_configdir unless @system_configdir.nil?
+      return @system_configdir = File.join(File::SEPARATOR, 'opt', 'puppetlabs', 'pdk', 'config') unless Gem.win_platform?
+
+      return @system_configdir = File.join(PDK::Util::Env['ProgramData'], 'PuppetLabs', 'PDK') unless PDK::Util::Env['ProgramData'].nil?
+      @system_configdir = File.join(PDK::Util::Env['AllUsersProfile'], 'PuppetLabs', 'PDK')
+    end
+    module_function :system_configdir
+
     # Returns path to the root of the module being worked on.
     #
     # @return [String, nil] Fully qualified base path to module, or nil if
@@ -176,7 +197,7 @@ module PDK
     # @return [Hash, nil] subset of text as Hash of first valid JSON found, or nil if no valid
     #   JSON found in the text
     def find_first_json_in(text)
-      find_valid_json_in(text)
+      find_all_json_in(text).first
     end
     module_function :find_first_json_in
 
@@ -186,42 +207,10 @@ module PDK
     # @return [Array<Hash>] subset of text as Array of all JSON object found, empty Array if none are found
     #   JSON found in the text
     def find_all_json_in(text)
-      find_valid_json_in(text, break_on_first: false)
+      PDK::Util::JSONFinder.new(text).objects
     end
     module_function :find_all_json_in
 
-    # Iterate through possible JSON documents until we find one that is valid.
-    #
-    # @param [String] text the text in which to find a JSON document
-    # @param [Hash] opts options
-    # @option opts [Boolean] :break_on_first Whether or not to break after valid JSON is found, defaults to true
-    #
-    # @return [Hash, Array<Hash>, nil] subset of text as Hash of first valid JSON found, array of all valid JSON found, or nil if no valid
-    #   JSON found in the text
-    #
-    # @private
-    def find_valid_json_in(text, opts = {})
-      break_on_first = opts.key?(:break_on_first) ? opts[:break_on_first] : true
-
-      json_result = break_on_first ? nil : []
-
-      text.scan(%r{\{(?:[^{}]|(?:\g<0>))*\}}x) do |str|
-        begin
-          if break_on_first
-            json_result = JSON.parse(str)
-            break
-          else
-            json_result.push(JSON.parse(str))
-          end
-        rescue JSON::ParserError
-          next
-        end
-      end
-
-      json_result
-    end
-    module_function :find_valid_json_in
-
     # Returns the targets' paths relative to the working directory
     #
     # @return [Array<String>] The absolute or path to the target
@@ -237,16 +226,18 @@ module PDK
     module_function :targets_relative_to_pwd
 
     # TO-DO: Refactor replacement of lib/pdk/module/build.rb:metadata to use this function instead
-    def module_metadata
+    # @param module_path [String] The path to the root of the module. Default is determine the module root automatically
+    def module_metadata(module_path = nil)
       require 'pdk/module/metadata'
-
-      PDK::Module::Metadata.from_file(File.join(module_root, 'metadata.json')).data
+      module_path ||= module_root
+      PDK::Module::Metadata.from_file(File.join(module_path, 'metadata.json')).data
     end
     module_function :module_metadata
 
     # TO-DO: Refactor replacement of lib/pdk/module/build.rb:module_pdk_compatible? to use this function instead
-    def module_pdk_compatible?
-      ['pdk-version', 'template-url'].any? { |key| module_metadata.key?(key) }
+    # @param module_path [String] The path to the root of the module. Default is determine the module root automatically
+    def module_pdk_compatible?(module_path = nil)
+      ['pdk-version', 'template-url'].any? { |key| module_metadata(module_path).key?(key) }
     end
     module_function :module_pdk_compatible?
 
@@ -263,5 +254,24 @@ module PDK
       nil
     end
     module_function :module_pdk_version
+
+    # Does a deep copy instead of a shallow copy of an object.
+    #
+    # @param object [Object] The object to duplicate
+    #
+    # @return [Object] duplicate of the original object
+    #   the current working dir does not appear to be within a module.
+    def deep_duplicate(object)
+      if object.is_a?(Array)
+        object.map { |item| deep_duplicate(item) }
+      elsif object.is_a?(Hash)
+        hash = object.dup
+        hash.each_pair { |key, value| hash[key] = deep_duplicate(value) }
+        hash
+      else
+        object
+      end
+    end
+    module_function :deep_duplicate
   end
 end