pdk 2.4.0 → 2.5.0

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

@@ -1,102 +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
+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/renderer/v1.rb

@@ -1,25 +1,25 @@
-require 'pdk'
-
-module PDK
-  module Template
-    module Renderer
-      module V1
-        autoload :LegacyTemplateDir, 'pdk/template/renderer/v1/legacy_template_dir'
-        autoload :Renderer, 'pdk/template/renderer/v1/renderer'
-        autoload :TemplateFile, 'pdk/template/renderer/v1/template_file'
-
-        # Whether the template directory and context are valid for the V1 renderer
-        # @see PDK::Template::Renderer.instance
-        def self.compatible?(template_root, _context)
-          %w[moduleroot moduleroot_init].all? { |dir| PDK::Util::Filesystem.directory?(File.join(template_root, dir)) }
-        end
-
-        # Creates an instance of the V1 Renderer
-        # @see PDK::Template::Renderer.instance
-        def self.instance(template_root, template_uri, context)
-          PDK::Template::Renderer::V1::Renderer.new(template_root, template_uri, context)
-        end
-      end
-    end
-  end
-end
+require 'pdk'
+
+module PDK
+  module Template
+    module Renderer
+      module V1
+        autoload :LegacyTemplateDir, 'pdk/template/renderer/v1/legacy_template_dir'
+        autoload :Renderer, 'pdk/template/renderer/v1/renderer'
+        autoload :TemplateFile, 'pdk/template/renderer/v1/template_file'
+
+        # Whether the template directory and context are valid for the V1 renderer
+        # @see PDK::Template::Renderer.instance
+        def self.compatible?(template_root, _context)
+          %w[moduleroot moduleroot_init].all? { |dir| PDK::Util::Filesystem.directory?(File.join(template_root, dir)) }
+        end
+
+        # Creates an instance of the V1 Renderer
+        # @see PDK::Template::Renderer.instance
+        def self.instance(template_root, template_uri, context)
+          PDK::Template::Renderer::V1::Renderer.new(template_root, template_uri, context)
+        end
+      end
+    end
+  end
+end

data/lib/pdk/template/renderer.rb

@@ -1,96 +1,96 @@
-require 'pdk'
-
-module PDK
-  module Template
-    module Renderer
-      autoload :V1, 'pdk/template/renderer/v1'
-
-      # Returns the most appropriate renderer for the given Template Directory and Context
-      #
-      # @param template_root [String] The path to where the template exists on disk
-      # @param template_uri [PDK::Util::TemplateUri] A URI which points to the source location of the Template
-      # @param context [PDK::Context] The context in which the redering will occur in
-      #
-      # @return [AbstractRenderer, nil] An instance of an AbstractRenderer subclass. Returns nil if no renderer could be found
-      def self.instance(template_uri, template_root, context)
-        return V1.instance(template_root, template_uri, context) if V1.compatible?(template_root, context)
-        nil
-      end
-
-      # An abstract class which all Template Renderers should subclass and implement. This class is responsible for
-      # rendering a template or a single item within a template directory
-      #
-      # To implement a new renderer:
-      # 1. Create a new class which subclasses AbstractRenderer and implements the public methods (has_single_item?, render and render_single_item)
-      # 2. Add class methods .compatible? and .instance which are used to detect if a template is compatible with the new renderer
-      #    and create an instance of the new renderer respectively
-      # 3. Update the PDK::Template::Renderer.instance method to detect and create an instance of the new renderer (using the .compatible? and .instance methods
-      #    created in step 2).
-      #
-      # See the PDK::Template::Renderer::V1 module and classes for an example on how to to this.
-      #
-      # @api private
-      # @abstract
-      class AbstractRenderer
-        # @return [String] The path to where the template exists on disk
-        attr_reader :template_root
-
-        # @return [PDK::Util::TemplateURI] The URI which points to the source location of the Template
-        attr_reader :template_uri
-
-        # @return context [PDK::Context] The context in which the redering will occur in
-        attr_reader :context
-
-        # @param template_root [String] The path to where the template exists on disk
-        # @param template_uri [PDK::Util::TemplateUri] A URI which points to the source location of the Template
-        # @param context [PDK::Context] The context in which the redering will occur in
-        def initialize(template_root, template_uri, context)
-          @template_root = template_root
-          @template_uri = template_uri
-          @context = context
-        end
-
-        # Whether the renderer supports rendering the a single item called 'item_path'. This is used when rendering things like a new Task or a new Puppet Classes.
-        # Rendering a single item is different than redering an entire project, like a entire Puppet Module or Control Repo.
-        #
-        # @param item_path [String] The path to the item to check
-        #
-        # @return [Boolean] Whether the renderer can render the item
-        # @abstract
-        def has_single_item?(_item_path) # rubocop:disable Naming/PredicateName Changing the method name to `single_item?` will convey the wrong intent
-          false
-        end
-
-        # Loop through the files in the template type, yielding each rendered file to the supplied block.
-        #
-        # @param template_type [PDK::Template::*_TEMPLATE_TYPE] The type of template to render
-        # @param name [String] The name to use in the rendering process
-        # @param options [Hash{Object => Object}] A list of options to pass through to the renderer. See PDK::Template::TemplateDir helper methods for other options
-        # @option options [Boolean] :include_first_time Whether to include "first time" items when rendering the project. While it is up to the renderer to implement this
-        #                                               the expected behavior is that if the item already exists, it will not be rendererd again.  Unlike normal items which
-        #                                               are always rendered to keep them in-sync
-        #
-        # @yieldparam dest_path [String] The path of the destination file, relative to the root of the context.
-        # @yieldparam dest_content [String] The rendered content of the destination file.
-        # @yieldparam dest_status [Symbol] :unmanage, :delete, :init, :manage
-        #
-        # @see PDK::Template::TemplateDir.render
-        #
-        # @return [void]
-        # @abstract
-        def render(template_type, name, options = {}); end
-
-        # Render a single item and return the resulting string. This is used when rendering things like a new Task or a new Puppet Classes.
-        # Rendering a single item is different than redering an entire project, like a entire Puppet Module or Control Repo. This method is
-        # used in conjunction with .has_single_item?
-        #
-        # @param item_path [String] The path of the single item to render
-        # @param template_data_hash [Hash{Object => Object}] A hash of information which will be used in the rendering process
-        #
-        # @return [String, Nil] The rendered content, or nil of the file could not be rendered
-        # @abstract
-        def render_single_item(item_path, template_data_hash = {}); end
-      end
-    end
-  end
-end
+require 'pdk'
+
+module PDK
+  module Template
+    module Renderer
+      autoload :V1, 'pdk/template/renderer/v1'
+
+      # Returns the most appropriate renderer for the given Template Directory and Context
+      #
+      # @param template_root [String] The path to where the template exists on disk
+      # @param template_uri [PDK::Util::TemplateUri] A URI which points to the source location of the Template
+      # @param context [PDK::Context] The context in which the redering will occur in
+      #
+      # @return [AbstractRenderer, nil] An instance of an AbstractRenderer subclass. Returns nil if no renderer could be found
+      def self.instance(template_uri, template_root, context)
+        return V1.instance(template_root, template_uri, context) if V1.compatible?(template_root, context)
+        nil
+      end
+
+      # An abstract class which all Template Renderers should subclass and implement. This class is responsible for
+      # rendering a template or a single item within a template directory
+      #
+      # To implement a new renderer:
+      # 1. Create a new class which subclasses AbstractRenderer and implements the public methods (has_single_item?, render and render_single_item)
+      # 2. Add class methods .compatible? and .instance which are used to detect if a template is compatible with the new renderer
+      #    and create an instance of the new renderer respectively
+      # 3. Update the PDK::Template::Renderer.instance method to detect and create an instance of the new renderer (using the .compatible? and .instance methods
+      #    created in step 2).
+      #
+      # See the PDK::Template::Renderer::V1 module and classes for an example on how to to this.
+      #
+      # @api private
+      # @abstract
+      class AbstractRenderer
+        # @return [String] The path to where the template exists on disk
+        attr_reader :template_root
+
+        # @return [PDK::Util::TemplateURI] The URI which points to the source location of the Template
+        attr_reader :template_uri
+
+        # @return context [PDK::Context] The context in which the redering will occur in
+        attr_reader :context
+
+        # @param template_root [String] The path to where the template exists on disk
+        # @param template_uri [PDK::Util::TemplateUri] A URI which points to the source location of the Template
+        # @param context [PDK::Context] The context in which the redering will occur in
+        def initialize(template_root, template_uri, context)
+          @template_root = template_root
+          @template_uri = template_uri
+          @context = context
+        end
+
+        # Whether the renderer supports rendering the a single item called 'item_path'. This is used when rendering things like a new Task or a new Puppet Classes.
+        # Rendering a single item is different than redering an entire project, like a entire Puppet Module or Control Repo.
+        #
+        # @param item_path [String] The path to the item to check
+        #
+        # @return [Boolean] Whether the renderer can render the item
+        # @abstract
+        def has_single_item?(_item_path) # rubocop:disable Naming/PredicateName Changing the method name to `single_item?` will convey the wrong intent
+          false
+        end
+
+        # Loop through the files in the template type, yielding each rendered file to the supplied block.
+        #
+        # @param template_type [PDK::Template::*_TEMPLATE_TYPE] The type of template to render
+        # @param name [String] The name to use in the rendering process
+        # @param options [Hash{Object => Object}] A list of options to pass through to the renderer. See PDK::Template::TemplateDir helper methods for other options
+        # @option options [Boolean] :include_first_time Whether to include "first time" items when rendering the project. While it is up to the renderer to implement this
+        #                                               the expected behavior is that if the item already exists, it will not be rendererd again.  Unlike normal items which
+        #                                               are always rendered to keep them in-sync
+        #
+        # @yieldparam dest_path [String] The path of the destination file, relative to the root of the context.
+        # @yieldparam dest_content [String] The rendered content of the destination file.
+        # @yieldparam dest_status [Symbol] :unmanage, :delete, :init, :manage
+        #
+        # @see PDK::Template::TemplateDir.render
+        #
+        # @return [void]
+        # @abstract
+        def render(template_type, name, options = {}); end
+
+        # Render a single item and return the resulting string. This is used when rendering things like a new Task or a new Puppet Classes.
+        # Rendering a single item is different than redering an entire project, like a entire Puppet Module or Control Repo. This method is
+        # used in conjunction with .has_single_item?
+        #
+        # @param item_path [String] The path of the single item to render
+        # @param template_data_hash [Hash{Object => Object}] A hash of information which will be used in the rendering process
+        #
+        # @return [String, Nil] The rendered content, or nil of the file could not be rendered
+        # @abstract
+        def render_single_item(item_path, template_data_hash = {}); end
+      end
+    end
+  end
+end

data/lib/pdk/template/template_dir.rb

@@ -1,67 +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
+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