pdk 1.15.0 → 2.0.0

data/lib/pdk/module/template_dir/git.rb

@@ -1,91 +0,0 @@
-require 'pdk'
-require 'pdk/module/template_dir/base'
-
-module PDK
-  module Module
-    module TemplateDir
-      class Git < Base
-        def template_path(uri)
-          # We don't do a checkout of local-path repos. There are lots of edge
-          # cases or user un-expectations.
-          if PDK::Util::Git.work_tree?(uri.shell_path)
-            PDK.logger.warn _("Repository '%{repo}' has a work-tree; skipping git reset.") % {
-              repo: uri.shell_path,
-            }
-            [uri.shell_path, false]
-          else
-            # This is either a bare local repo or a remote. either way it needs cloning.
-            # A "remote" can also be git repo on the local filsystem.
-            [clone_template_repo(uri), true]
-          end
-        end
-
-        # 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.
-        def metadata
-          super.merge('template-url' => uri.metadata_format, 'template-ref' => cache_template_ref(@path))
-        end
-
-        private
-
-        def cache_template_ref(path, ref = nil)
-          require 'pdk/util/git'
-
-          @template_ref ||= PDK::Util::Git.describe(File.join(path, '.git'), ref)
-        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 clone_template_repo(uri)
-          # @todo When switching this over to using rugged, cache the cloned
-          # template repo in `%AppData%` or `$XDG_CACHE_DIR` and update before
-          # use.
-          require 'pdk/util'
-          require 'pdk/util/git'
-
-          temp_dir = PDK::Util.make_tmpdir_name('pdk-templates')
-          origin_repo = uri.bare_uri
-          git_ref = uri.uri_fragment
-
-          clone_result = PDK::Util::Git.git('clone', origin_repo, temp_dir)
-
-          if clone_result[:exit_code].zero?
-            checkout_template_ref(temp_dir, git_ref)
-          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
-
-        # @api private
-        def checkout_template_ref(path, ref)
-          require 'pdk/util/git'
-
-          if PDK::Util::Git.work_dir_clean?(path)
-            Dir.chdir(path) do
-              full_ref = PDK::Util::Git.ls_remote(path, ref)
-              cache_template_ref(path, full_ref)
-              reset_result = PDK::Util::Git.git('reset', '--hard', full_ref)
-              return if reset_result[:exit_code].zero?
-
-              PDK.logger.error reset_result[:stdout]
-              PDK.logger.error reset_result[:stderr]
-              raise PDK::CLI::FatalError, _("Unable to checkout '%{ref}' of git repository at '%{path}'.") % { ref: ref, path: path }
-            end
-          else
-            PDK.logger.warn _("Uncommitted changes found when attempting to checkout '%{ref}' of git repository at '%{path}'; skipping git reset.") % { ref: ref, path: path }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pdk/module/template_dir/local.rb

@@ -1,21 +0,0 @@
-require 'pdk'
-require 'pdk/module/template_dir/base'
-
-module PDK
-  module Module
-    module TemplateDir
-      class Local < Base
-        def template_path(uri)
-          [uri.shell_path, false]
-        end
-
-        # For plain fileystem directories, this will return the URL to the repository only.
-        #
-        # @return [Hash{String => String}] A hash of identifying metadata.
-        def metadata
-          super.merge('template-url' => uri.bare_uri)
-        end
-      end
-    end
-  end
-end

data/lib/pdk/template_file.rb

@@ -1,96 +0,0 @@
-require 'ostruct'
-require 'pdk'
-
-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 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

data/lib/pdk/validate/base_validator.rb

@@ -1,215 +0,0 @@
-require 'pdk'
-
-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 PDK::Util::Filesystem.directory?(target)
-              target_root = PDK::Util.module_root
-              pattern_glob = Array(pattern).map { |p| PDK::Util::Filesystem.glob(File.join(target_root, p), File::FNM_DOTMATCH) }
-              target_list = pattern_glob.flatten
-                                        .select { |glob| PDK::Util::Filesystem.fnmatch(File.join(PDK::Util::Filesystem.expand_path(PDK::Util.canonical_path(target)), '*'), glob, File::FNM_DOTMATCH) }
-                                        .map { |glob| Pathname.new(glob).relative_path_from(Pathname.new(PDK::Util.module_root)).to_s }
-
-              ignore_list = ignore_pathspec
-              target_list = target_list.reject { |file| ignore_list.match(file) }
-
-              skipped << target if target_list.flatten.empty?
-              target_list
-            elsif PDK::Util::Filesystem.file?(target)
-              if Array(pattern).include? target
-                target
-              elsif Array(pattern).any? { |p| PDK::Util::Filesystem.fnmatch(PDK::Util::Filesystem.expand_path(p), PDK::Util::Filesystem.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
-        require 'pdk/module'
-
-        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 = {})
-        require 'pdk/cli/exec/command'
-
-        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
-          require 'pdk/cli/exec_group'
-          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

data/lib/pdk/validate/metadata/metadata_json_lint.rb

@@ -1,82 +0,0 @@
-require 'pdk'
-
-module PDK
-  module Validate
-    class MetadataJSONLint < BaseValidator
-      # Validate each metadata file separately, as metadata-json-lint does not
-      # support multiple targets.
-      INVOKE_STYLE = :per_target
-
-      def self.name
-        'metadata-json-lint'
-      end
-
-      def self.cmd
-        'metadata-json-lint'
-      end
-
-      def self.spinner_text(targets = [])
-        _('Checking module metadata style (%{targets}).') % {
-          targets: PDK::Util.targets_relative_to_pwd(targets).join(' '),
-        }
-      end
-
-      def self.pattern
-        'metadata.json'
-      end
-
-      def self.parse_options(_options, targets)
-        cmd_options = ['--format', 'json']
-        cmd_options << '--strict-dependencies'
-
-        cmd_options.concat(targets)
-      end
-
-      def self.parse_output(report, result, targets)
-        raise ArgumentError, _('More than 1 target provided to PDK::Validate::MetadataJSONLint.') if targets.count > 1
-
-        if result[:stdout].strip.empty?
-          # metadata-json-lint will print nothing if there are no problems with
-          # the file being linted. This should be handled separately to
-          # metadata-json-lint generating output that can not be parsed as JSON
-          # (unhandled exception in metadata-json-lint).
-          json_data = {}
-        else
-          begin
-            json_data = JSON.parse(result[:stdout])
-          rescue JSON::ParserError
-            raise PDK::Validate::ParseOutputError, result[:stdout]
-          end
-        end
-
-        if json_data.empty?
-          report.add_event(
-            file:     targets.first,
-            source:   name,
-            state:    :passed,
-            severity: :ok,
-          )
-        else
-          json_data.delete('result')
-          json_data.keys.each do |type|
-            json_data[type].each do |offense|
-              # metadata-json-lint groups the offenses by type, so the type ends
-              # up being `warnings` or `errors`. We want to convert that to the
-              # singular noun for the event.
-              event_type = type[%r{\A(.+?)s?\Z}, 1]
-
-              report.add_event(
-                file:     targets.first,
-                source:   name,
-                message:  offense['msg'],
-                test:     offense['check'],
-                severity: event_type,
-                state:    :failure,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end