pdk 1.9.0 → 3.2.0

data/lib/pdk/module/templatedir.rb

@@ -1,321 +0,0 @@
-require 'yaml'
-require 'deep_merge'
-require 'pdk/util'
-require 'pdk/util/git'
-require 'pdk/cli/errors'
-require 'pdk/template_file'
-
-module PDK
-  module Module
-    class TemplateDir
-      attr_accessor :module_metadata
-
-      # Initialises the TemplateDir object with the path or URL to the template
-      # and the block of code to run to be run while the template is available.
-      #
-      # The template directory is only guaranteed to be available on disk
-      # within the scope of the block passed to this method.
-      #
-      # @param path_or_url [String] The path to a directory to use as the
-      # template or a URL to a git repository.
-      # @param module_metadata [Hash] A Hash containing the module metadata.
-      # Defaults to an empty Hash.
-      # @yieldparam self [PDK::Module::TemplateDir] The initialised object with
-      # the template available on disk.
-      #
-      # @example Using a git repository as a template
-      #   PDK::Module::TemplateDir.new('https://github.com/puppetlabs/pdk-templates') do |t|
-      #     t.render do |filename, content|
-      #       File.open(filename, 'w') do |file|
-      #         file.write(content)
-      #       end
-      #     end
-      #   end
-      #
-      # @raise [ArgumentError] If no block is given to this method.
-      # @raise [PDK::CLI::FatalError] (see #clone_repo)
-      # @raise [ArgumentError] (see #validate_module_template!)
-      #
-      # @api public
-      def initialize(path_or_url, module_metadata = {}, init = false)
-        unless block_given?
-          raise ArgumentError, _('%{class_name} must be initialized with a block.') % { class_name: self.class.name }
-        end
-
-        if PDK::Util::Git.repo?(path_or_url)
-          @path = self.class.clone_template_repo(path_or_url)
-          @repo = path_or_url
-        else
-          @path = path_or_url
-        end
-
-        @init = init
-        @moduleroot_dir = File.join(@path, 'moduleroot')
-        @moduleroot_init = File.join(@path, 'moduleroot_init')
-        @dirs = [@moduleroot_dir]
-        @dirs << @moduleroot_init if @init
-        @object_dir = File.join(@path, 'object_templates')
-
-        validate_module_template!
-
-        @module_metadata = module_metadata
-
-        yield self
-      ensure
-        # If we cloned a git repo to get the template, remove the clone once
-        # we're done with it.
-        if @repo
-          FileUtils.remove_dir(@path)
-        end
-      end
-
-      # Retrieve identifying metadata for the template.
-      #
-      # For git repositories, this will return the URL to the repository and
-      # a reference to the HEAD.
-      #
-      # @return [Hash{String => String}] A hash of identifying metadata.
-      #
-      # @api public
-      def metadata
-        result = {
-          'pdk-version' => PDK::Util::Version.version_string,
-        }
-
-        result['template-url'] = @repo ? @repo : @path
-
-        ref_result = PDK::Util::Git.git('--git-dir', File.join(@path, '.git'), 'describe', '--all', '--long', '--always')
-        result['template-ref'] = ref_result[:stdout].strip if ref_result[:exit_code].zero?
-
-        result
-      end
-
-      # Loop through the files in the template, yielding each rendered file to
-      # the supplied block.
-      #
-      # @yieldparam dest_path [String] The path of the destination file,
-      # relative to the root of the module.
-      # @yieldparam dest_content [String] The rendered content of the
-      # destination file.
-      #
-      # @raise [PDK::CLI::FatalError] If the template fails to render.
-      #
-      # @return [void]
-      #
-      # @api public
-      def render
-        PDK::Module::TemplateDir.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 = config_for(dest_path)
-          dest_status = :manage
-
-          if config['unmanaged']
-            dest_status = :unmanage
-          elsif config['delete']
-            dest_status = :delete
-          else
-            begin
-              dest_content = PDK::TemplateFile.new(File.join(template_loc, template_file), configs: config, template_dir: self).render
-            rescue => e
-              error_msg = _(
-                "Failed to render template '%{template}'\n" \
-                '%{exception}: %{message}',
-              ) % { template: template_file, exception: e.class, message: e.message }
-              raise PDK::CLI::FatalError, error_msg
-            end
-          end
-
-          yield dest_path, dest_content, dest_status
-        end
-      end
-
-      # Searches the template directory for template files that can be used to
-      # render files for the specified object type.
-      #
-      # @param object_type [Symbol] The object type, e.g. (`:class`,
-      # `:defined_type`, `:fact`, etc).
-      #
-      # @return [Hash{Symbol => String}] if the templates are available in the
-      # template dir, otherwise `nil`. The returned hash can contain two keys,
-      # :object contains the path on disk to the template for the object, :spec
-      # contains the path on disk to the template for the object's spec file
-      # (if available).
-      #
-      # @api public
-      def object_template_for(object_type)
-        object_path = File.join(@object_dir, "#{object_type}.erb")
-        type_path = File.join(@object_dir, "#{object_type}_type.erb")
-        spec_path = File.join(@object_dir, "#{object_type}_spec.erb")
-        type_spec_path = File.join(@object_dir, "#{object_type}_type_spec.erb")
-
-        if File.file?(object_path) && File.readable?(object_path)
-          result = { object: object_path }
-          result[:type] = type_path if File.file?(type_path) && File.readable?(type_path)
-          result[:spec] = spec_path if File.file?(spec_path) && File.readable?(spec_path)
-          result[:type_spec] = type_spec_path if File.file?(type_spec_path) && File.readable?(type_spec_path)
-          result
-        else
-          nil
-        end
-      end
-
-      # Generate a hash of data to be used when rendering object templates.
-      #
-      # Read `config_defaults.yml` from the root of the template directory (if
-      # it exists) build a hash of values from the value of the `:global`
-      # key.
-      #
-      # @return [Hash] The data that will be available to the template via the
-      # `@configs` instance variable.
-      #
-      # @api private
-      def object_config
-        config_for(nil)
-      end
-
-      # Validate the content of the template directory.
-      #
-      # @raise [ArgumentError] If the specified path is not a directory.
-      # @raise [ArgumentError] If the template directory does not contain
-      # a directory called 'moduleroot'.
-      #
-      # @return [void]
-      #
-      # @api private
-      def validate_module_template!
-        # rubocop:disable Style/GuardClause
-        unless File.directory?(@path)
-          if PDK::Util.package_install? && File.fnmatch?(File.join(PDK::Util.package_cachedir, '*'), @path)
-            raise ArgumentError, _('The built-in template has substantially changed. Please run "pdk convert" on your module to continue.')
-          else
-            raise ArgumentError, _("The specified template '%{path}' is not a directory.") % { path: @path }
-          end
-        end
-
-        unless File.directory?(@moduleroot_dir)
-          raise ArgumentError, _("The template at '%{path}' does not contain a 'moduleroot/' directory.") % { path: @path }
-        end
-
-        unless File.directory?(@moduleroot_init)
-          # rubocop:disable Metrics/LineLength
-          raise ArgumentError, _("The template at '%{path}' does not contain a 'moduleroot_init/' directory, which indicates you are using an older style of template. Before continuing please use the --template-url flag when running the pdk new commands to pass a new style template.") % { path: @path }
-          # rubocop:enable Metrics/LineLength Style/GuardClause
-        end
-      end
-
-      # Get a list of template files in the template directory.
-      #
-      # @return [Hash{String=>String}] A hash of key file names and
-      # value locations.
-      #
-      # @api public
-      def self.files_in_template(dirs)
-        temp_paths = []
-        dirlocs = []
-        dirs.each do |dir|
-          raise ArgumentError, _("The directory '%{dir}' doesn't exist") % { dir: dir } unless Dir.exist?(dir)
-          temp_paths += Dir.glob(File.join(dir, '**', '*'), File::FNM_DOTMATCH).select do |template_path|
-            if File.file?(template_path) && !File.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
-
-      # Generate a hash of data to be used when rendering the specified
-      # template.
-      #
-      # @param dest_path [String] The destination path of the file that the
-      # data is for, relative to the root of the module.
-      #
-      # @return [Hash] The data that will be available to the template via the
-      # `@configs` instance variable.
-      #
-      # @api private
-      def config_for(dest_path, sync_config_path = nil)
-        module_root = PDK::Util.module_root
-        sync_config_path ||= File.join(module_root, '.sync.yml') unless module_root.nil?
-        config_path = File.join(@path, 'config_defaults.yml')
-
-        if @config.nil?
-          conf_defaults = read_config(config_path)
-          sync_config = read_config(sync_config_path) unless sync_config_path.nil?
-          @config = conf_defaults
-          @config.deep_merge!(sync_config, knockout_prefix: '---') unless sync_config.nil?
-        end
-        file_config = @config.fetch(:global, {})
-        file_config['module_metadata'] = @module_metadata
-        file_config.merge!(@config.fetch(dest_path, {})) unless dest_path.nil?
-        file_config.merge!(@config)
-      end
-
-      # Generates a hash of data from a given yaml file location.
-      #
-      # @param loc [String] The path of the yaml config file.
-      #
-      # @warn If the specified path is not a valid yaml file. Returns an empty Hash
-      # if so.
-      #
-      # @return [Hash] The data that has been read in from the given yaml file.
-      #
-      # @api private
-      def read_config(loc)
-        if File.file?(loc) && File.readable?(loc)
-          begin
-            YAML.safe_load(File.read(loc), [], [], true)
-          rescue Psych::SyntaxError => e
-            PDK.logger.warn _("'%{file}' is not a valid YAML file: %{problem} %{context} at line %{line} column %{column}") % {
-              file:    loc,
-              problem: e.problem,
-              context: e.context,
-              line:    e.line,
-              column:  e.column,
-            }
-            {}
-          end
-        else
-          {}
-        end
-      end
-
-      # @return [String] Path to working directory into which template repo has been cloned and reset
-      #
-      # @raise [PDK::CLI::FatalError] If unable to clone the given origin_repo into a tempdir.
-      # @raise [PDK::CLI::FatalError] If reset HEAD of the cloned repo to desired ref.
-      #
-      # @api private
-      def self.clone_template_repo(origin_repo)
-        # @todo When switching this over to using rugged, cache the cloned
-        # template repo in `%AppData%` or `$XDG_CACHE_DIR` and update before
-        # use.
-        temp_dir = PDK::Util.make_tmpdir_name('pdk-templates')
-        git_ref = (origin_repo == PDK::Util.default_template_url) ? PDK::Util.default_template_ref : 'origin/master'
-
-        clone_result = PDK::Util::Git.git('clone', origin_repo, temp_dir)
-
-        if clone_result[:exit_code].zero?
-          Dir.chdir(temp_dir) do
-            reset_result = PDK::Util::Git.git('reset', '--hard', git_ref)
-            unless reset_result[:exit_code].zero?
-              PDK.logger.error reset_result[:stdout]
-              PDK.logger.error reset_result[:stderr]
-              raise PDK::CLI::FatalError, _("Unable to set HEAD of git repository at '%{repo}' to ref:'%{ref}'.") % { repo: temp_dir, ref: git_ref }
-            end
-          end
-        else
-          PDK.logger.error clone_result[:stdout]
-          PDK.logger.error clone_result[:stderr]
-          raise PDK::CLI::FatalError, _("Unable to clone git repository at '%{repo}' into '%{dest}'.") % { repo: origin_repo, dest: temp_dir }
-        end
-
-        PDK::Util.canonical_path(temp_dir)
-      end
-    end
-  end
-end

data/lib/pdk/template_file.rb

@@ -1,95 +0,0 @@
-require 'ostruct'
-
-module PDK
-  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 nil 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 File.file?(@template_file) && File.readable?(@template_file)
-        return File.read(@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

data/lib/pdk/validate/base_validator.rb

@@ -1,215 +0,0 @@
-require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/module'
-
-module PDK
-  module Validate
-    class BaseValidator
-      # Controls how many times the validator is invoked.
-      #
-      #   :once -       The validator will be invoked once and passed all the
-      #                 targets.
-      #   :per_target - The validator will be invoked for each target
-      #                 separately.
-      INVOKE_STYLE = :once
-
-      # Controls how the validator behaves if not passed any targets.
-      #
-      #   true  - PDK will not pass the globbed targets to the validator command
-      #           and it will instead rely on the underlying tool to find its
-      #           own default targets.
-      #   false - PDK will pass the globbed targets to the validator command.
-      ALLOW_EMPTY_TARGETS = false
-
-      IGNORE_DOTFILES = true
-
-      def self.cmd_path
-        File.join(PDK::Util.module_root, 'bin', cmd)
-      end
-
-      # Parses the target strings provided from the CLI
-      #
-      # @param options [Hash] A Hash containing the input options from the CLI.
-      #
-      # @return targets [Array] An Array of Strings containing target file paths
-      #                         for the validator to validate.
-      # @return skipped [Array] An Array of Strings containing targets
-      #                         that are skipped due to target not containing
-      #                         any files that can be validated by the validator.
-      # @return invalid [Array] An Array of Strings containing targets that do
-      #                         not exist, and will not be run by validator.
-      def self.parse_targets(options)
-        # If no targets are specified, then we will run validations from the
-        # base module directory.
-
-        targets = options.fetch(:targets, []).empty? ? [PDK::Util.module_root] : options[:targets]
-
-        targets.map! { |r| r.gsub(File::ALT_SEPARATOR, File::SEPARATOR) } if File::ALT_SEPARATOR
-        skipped = []
-        invalid = []
-        matched = targets.map { |target|
-          if respond_to?(:pattern)
-            if File.directory?(target)
-              target_root = PDK::Util.module_root
-              pattern_glob = Array(pattern).map { |p| Dir.glob(File.join(target_root, p), File::FNM_DOTMATCH) }
-
-              target_list = pattern_glob.flatten.map do |file|
-                if File.fnmatch(File.join(File.expand_path(target), '*'), file, File::FNM_DOTMATCH)
-                  Pathname.new(file).relative_path_from(Pathname.new(PDK::Util.module_root)).to_s
-                end
-              end
-
-              ignore_list = ignore_pathspec
-              target_list = target_list.reject { |file| ignore_list.match(file) }
-
-              skipped << target if target_list.flatten.empty?
-              target_list
-            elsif File.file?(target)
-              if Array(pattern).include? target
-                target
-              elsif Array(pattern).any? { |p| File.fnmatch(File.expand_path(p), File.expand_path(target), File::FNM_DOTMATCH) }
-                target
-              else
-                skipped << target
-                next
-              end
-            else
-              invalid << target
-              next
-            end
-          else
-            target
-          end
-        }.compact.flatten
-        [matched, skipped, invalid]
-      end
-
-      def self.ignore_pathspec
-        ignore_pathspec = PDK::Module.default_ignored_pathspec(ignore_dotfiles?)
-
-        if respond_to?(:pattern_ignore)
-          Array(pattern_ignore).each do |pattern|
-            ignore_pathspec.add(pattern)
-          end
-        end
-
-        ignore_pathspec
-      end
-
-      def self.ignore_dotfiles?
-        self::IGNORE_DOTFILES
-      end
-
-      def self.parse_options(_options, targets)
-        targets
-      end
-
-      def self.spinner_text(_targets = nil)
-        _('Invoking %{cmd}') % { cmd: cmd }
-      end
-
-      def self.process_skipped(report, skipped = [])
-        skipped.each do |skipped_target|
-          PDK.logger.debug(_('%{validator}: Skipped \'%{target}\'. Target does not contain any files to validate (%{pattern}).') % { validator: name, target: skipped_target, pattern: pattern })
-          report.add_event(
-            file:     skipped_target,
-            source:   name,
-            message:  _('Target does not contain any files to validate (%{pattern}).') % { pattern: pattern },
-            severity: :info,
-            state:    :skipped,
-          )
-        end
-      end
-
-      def self.process_invalid(report, invalid = [])
-        invalid.each do |invalid_target|
-          PDK.logger.debug(_('%{validator}: Skipped \'%{target}\'. Target file not found.') % { validator: name, target: invalid_target })
-          report.add_event(
-            file:     invalid_target,
-            source:   name,
-            message:  _('File does not exist.'),
-            severity: :error,
-            state:    :error,
-          )
-        end
-      end
-
-      def self.allow_empty_targets?
-        self::ALLOW_EMPTY_TARGETS == true
-      end
-
-      def self.invoke(report, options = {})
-        targets, skipped, invalid = parse_targets(options)
-
-        process_skipped(report, skipped)
-        process_invalid(report, invalid)
-
-        return 0 if targets.empty?
-
-        PDK::Util::Bundler.ensure_binstubs!(cmd)
-
-        # If invoking :per_target, split the targets array into an array of
-        # single element arrays (one per target). If invoking :once, wrap the
-        # targets array in another array. This is so we can loop through the
-        # invokes with the same logic, regardless of which invoke style is
-        # needed.
-        #
-        if self::INVOKE_STYLE == :per_target
-          targets = targets.combination(1).to_a
-        else
-          targets = targets.each_slice(1000).to_a
-          options[:split_exec] = PDK::CLI::ExecGroup.new(spinner_text(targets), parallel: false)
-        end
-
-        if options.fetch(:targets, []).empty? && allow_empty_targets?
-          targets = [[]]
-        end
-
-        exit_codes = []
-
-        targets.each do |invokation_targets|
-          cmd_argv = parse_options(options, invokation_targets).unshift(cmd_path).compact
-          cmd_argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe'), '-W0') if Gem.win_platform?
-
-          command = PDK::CLI::Exec::Command.new(*cmd_argv).tap do |c|
-            c.context = :module
-            c.environment = { 'PUPPET_GEM_VERSION' => options[:puppet] } if options[:puppet]
-            unless options[:split_exec]
-              exec_group = options[:exec_group]
-              if exec_group
-                sub_spinner = exec_group.add_spinner(spinner_text(invokation_targets))
-                c.register_spinner(sub_spinner)
-              else
-                c.add_spinner(spinner_text(invokation_targets))
-              end
-            end
-          end
-
-          if options[:split_exec]
-            options[:split_exec].register do
-              result = command.execute!
-
-              begin
-                parse_output(report, result, invokation_targets.compact)
-              rescue PDK::Validate::ParseOutputError => e
-                $stderr.puts e.message
-              end
-              result[:exit_code]
-            end
-          else
-            result = command.execute!
-            exit_codes << result[:exit_code]
-
-            begin
-              parse_output(report, result, invokation_targets.compact)
-            rescue PDK::Validate::ParseOutputError => e
-              $stderr.puts e.message
-            end
-          end
-        end
-
-        options.key?(:split_exec) ? options[:split_exec].exit_code : exit_codes.max
-      end
-    end
-  end
-end