bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/module/task.rb

@@ -1,258 +0,0 @@
-require 'puppet/util/logging'
-
-class Puppet::Module
-  class Task
-    class Error < Puppet::Error
-      attr_accessor :kind, :details
-      def initialize(message, kind, details = nil)
-        super(message)
-        @details = details || {}
-        @kind = kind
-      end
-
-      def to_h
-        {
-          msg: message,
-          kind: kind,
-          details: details
-        }
-      end
-    end
-
-    class InvalidName < Error
-      def initialize(name)
-        msg = _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
-        super(msg, 'puppet.tasks/invalid-name')
-      end
-    end
-
-    class InvalidFile < Error
-      def initialize(msg)
-        super(msg, 'puppet.tasks/invalid-file')
-      end
-    end
-
-    class InvalidTask < Error
-    end
-    class InvalidMetadata < Error
-    end
-    class TaskNotFound < Error
-      def initialize(task_name, module_name)
-        msg = _("Task %{task_name} not found in module %{module_name}.") %
-          {task_name: task_name, module_name: module_name}
-        super(msg, 'puppet.tasks/task-not-found', { 'name' => task_name })
-      end
-    end
-
-    FORBIDDEN_EXTENSIONS = %w{.conf .md}
-    MOUNTS = %w[lib files tasks]
-
-    def self.is_task_name?(name)
-      return true if name =~ /^[a-z][a-z0-9_]*$/
-      return false
-    end
-
-    # Determine whether a file has a legal name for either a task's executable or metadata file.
-    def self.is_tasks_filename?(path)
-      name_less_extension = File.basename(path, '.*')
-      return false if not is_task_name?(name_less_extension)
-      FORBIDDEN_EXTENSIONS.each do |ext|
-        return false if path.end_with?(ext)
-      end
-      return true
-    end
-
-    def self.get_file_details(path, mod)
-      # This gets the path from the starting point onward
-      # For files this should be the file subpath from the metadata
-      # For directories it should be the directory subpath plus whatever we globbed
-      # Partition matches on the first instance it finds of the parameter
-      name = "#{mod.name}#{path.partition(mod.path).last}"
-
-      { "name" => name, "path" =>  path }
-    end
-    private_class_method :get_file_details
-
-    # Find task's required lib files and retrieve paths for both 'files' and 'implementation:files' metadata keys
-    def self.find_extra_files(metadata, envname = nil)
-      return [] if metadata.nil?
-
-      files = metadata.fetch('files', []) +
-        metadata.fetch('implementations', []).flat_map { |impl| impl.fetch('files', []) }
-
-      files.uniq.flat_map do |file|
-        module_name, mount, endpath = file.split("/", 3)
-        # If there's a mount directory with no trailing slash this will be nil
-        # We want it to be empty to construct a path
-        endpath ||= ''
-
-        pup_module = Puppet::Module.find(module_name, envname)
-        if pup_module.nil?
-          msg = _("Could not find module %{module_name} containing task file %{filename}" %
-                  {module_name: module_name, filename: endpath})
-          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
-        end
-
-        unless MOUNTS.include? mount
-          msg = _("Files must be saved in module directories that Puppet makes available via mount points: %{mounts}" %
-                  {mounts: MOUNTS.join(', ')})
-          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
-        end
-
-        path = File.join(pup_module.path, mount, endpath)
-        unless File.absolute_path(path) == File.path(path).chomp('/')
-          msg = _("File pathnames cannot include relative paths")
-          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
-        end
-
-        unless File.exist?(path)
-          msg = _("Could not find %{path} on disk" % { path: path })
-          raise InvalidFile.new(msg)
-        end
-
-        last_char = file[-1] == '/'
-        if File.directory?(path)
-          unless last_char
-            msg = _("Directories specified in task metadata must include a trailing slash: %{dir}" % { dir: file } )
-            raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
-          end
-          dir_files = Dir.glob("#{path}**/*").select { |f| File.file?(f) }
-          dir_files.map { |f| get_file_details(f, pup_module) }
-        else
-          if last_char
-            msg = _("Files specified in task metadata cannot include a trailing slash: %{file}" % { file: file } )
-            raise InvalidMetadata.new(msg, 'puppet.task/invalid-metadata')
-          end
-          get_file_details(path, pup_module)
-        end
-      end
-    end
-    private_class_method :find_extra_files
-
-    # Executables list should contain the full path of all possible implementation files
-    def self.find_implementations(name, directory, metadata, executables)
-      basename = name.split('::')[1] || 'init'
-      # If 'implementations' is defined, it needs to mention at least one
-      # implementation, and everything it mentions must exist.
-      metadata ||= {}
-      if metadata.key?('implementations')
-        unless metadata['implementations'].is_a?(Array)
-          msg = _("Task metadata for task %{name} does not specify implementations as an array" % { name: name })
-          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
-        end
-
-        implementations = metadata['implementations'].map do |impl|
-          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
-          unless path
-            msg = _("Task metadata for task %{name} specifies missing implementation %{implementation}" % { name: name, implementation: impl['name'] })
-            raise InvalidTask.new(msg, 'puppet.tasks/missing-implementation', { missing: [impl['name']] } )
-          end
-          { "name" => impl['name'], "path" => path }
-        end
-        return implementations
-      end
-
-      # If implementations isn't defined, then we use executables matching the
-      # task name, and only one may exist.
-      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
-      if implementations.empty?
-        msg = _('No source besides task metadata was found in directory %{directory} for task %{name}') %
-          { name: name, directory: directory }
-        raise InvalidTask.new(msg, 'puppet.tasks/no-implementation')
-      elsif implementations.length > 1
-        msg =_("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
-          { name: name, directory: implementations[0] }
-        raise InvalidTask.new(msg, 'puppet.tasks/multiple-implementations')
-      end
-
-      [{ "name" => File.basename(implementations.first), "path" => implementations.first }]
-    end
-    private_class_method :find_implementations
-
-    def self.find_files(name, directory, metadata, executables, envname = nil)
-      # PXP agent relies on 'impls' (which is the task file) being first if there is no metadata
-      find_implementations(name, directory, metadata, executables) + find_extra_files(metadata, envname)
-    end
-
-    def self.is_tasks_metadata_filename?(name)
-      is_tasks_filename?(name) && name.end_with?('.json')
-    end
-
-    def self.is_tasks_executable_filename?(name)
-      is_tasks_filename?(name) && !name.end_with?('.json')
-    end
-
-    def self.tasks_in_module(pup_module)
-      task_files = Dir.glob(File.join(pup_module.tasks_directory, '*'))
-        .keep_if { |f| is_tasks_filename?(f) }
-
-      module_executables = task_files.reject(&method(:is_tasks_metadata_filename?)).map.to_a
-
-      tasks = task_files.group_by { |f| task_name_from_path(f) }
-
-      tasks.map do |task, executables|
-        new_with_files(pup_module, task, executables, module_executables)
-      end
-    end
-
-    attr_reader :name, :module, :metadata_file, :metadata
-
-    # file paths must be relative to the modules task directory
-    def initialize(pup_module, task_name,  module_executables, metadata_file = nil)
-      if !Puppet::Module::Task.is_task_name?(task_name)
-        raise InvalidName, _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
-      end
-
-      name = task_name == "init" ? pup_module.name : "#{pup_module.name}::#{task_name}"
-
-      @module = pup_module
-      @name = name
-      @metadata_file = metadata_file
-      @module_executables = module_executables || []
-    end
-
-    def self.read_metadata(file)
-      Puppet::Util::Json.load(Puppet::FileSystem.read(file, :encoding => 'utf-8')) if file
-    rescue SystemCallError, IOError => err
-      msg = _("Error reading metadata: %{message}" % {message: err.message})
-      raise InvalidMetadata.new(msg, 'puppet.tasks/unreadable-metadata')
-    rescue Puppet::Util::Json::ParseError => err
-      raise InvalidMetadata.new(err.message, 'puppet.tasks/unparseable-metadata')
-    end
-
-    def metadata
-      @metadata ||= self.class.read_metadata(@metadata_file)
-    end
-
-    def files
-      @files ||= self.class.find_files(@name, @module.tasks_directory, metadata, @module_executables, environment_name)
-    end
-
-    def validate
-      files
-      true
-    end
-
-    def ==(other)
-      self.name == other.name &&
-      self.module == other.module
-    end
-
-    def environment_name
-      @module.environment.respond_to?(:name) ? @module.environment.name : 'production'
-    end
-    private :environment_name
-
-    def self.new_with_files(pup_module, name, task_files, module_executables)
-      metadata_file = task_files.find { |f| is_tasks_metadata_filename?(f) }
-      Puppet::Module::Task.new(pup_module, name, module_executables, metadata_file)
-    end
-    private_class_method :new_with_files
-
-    # Abstracted here so we can add support for subdirectories later
-    def self.task_name_from_path(path)
-      return File.basename(path, '.*')
-    end
-    private_class_method :task_name_from_path
-  end
-end

data/vendored/puppet/lib/puppet/module_tool.rb

@@ -1,193 +0,0 @@
-# encoding: UTF-8
-# Load standard libraries
-require 'pathname'
-require 'fileutils'
-require 'puppet/util/colors'
-
-module Puppet
-  module ModuleTool
-    require 'puppet/module_tool/tar'
-    extend Puppet::Util::Colors
-
-    # Directory and names that should not be checksummed.
-    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
-    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
-    REPOSITORY_URL = Puppet.settings[:module_repository]
-
-    # Is this a directory that shouldn't be checksummed?
-    #
-    # TODO: Should this be part of Checksums?
-    # TODO: Rename this method to reflect its purpose?
-    # TODO: Shouldn't this be used when building packages too?
-    def self.artifact?(path)
-      case File.basename(path)
-      when *ARTIFACTS
-        true
-      else
-        false
-      end
-    end
-
-    # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
-    # ArgumentError if the argument isn't parseable.
-    def self.username_and_modname_from(full_module_name)
-      if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
-        return matcher.captures
-      else
-        raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
-      end
-    end
-
-    # Find the module root when given a path by checking each directory up from
-    # its current location until it finds one that satisfies is_module_root?
-    #
-    # @param path [Pathname, String] path to start from
-    # @return [Pathname, nil] the root path of the module directory or nil if
-    #   we cannot find one
-    def self.find_module_root(path)
-      path = Pathname.new(path) if path.class == String
-
-      path.expand_path.ascend do |p|
-        return p if is_module_root?(p)
-      end
-
-      nil
-    end
-
-    # Analyse path to see if it is a module root directory by detecting a
-    # file named 'metadata.json'
-    #
-    # @param path [Pathname, String] path to analyse
-    # @return [Boolean] true if the path is a module root, false otherwise
-    def self.is_module_root?(path)
-      path = Pathname.new(path) if path.class == String
-
-      FileTest.file?(path + 'metadata.json')
-    end
-
-    # Builds a formatted tree from a list of node hashes containing +:text+
-    # and +:dependencies+ keys.
-    def self.format_tree(nodes, level = 0)
-      str = ''
-      nodes.each_with_index do |node, i|
-        last_node = nodes.length - 1 == i
-        deps = node[:dependencies] || []
-
-        str << (indent = "  " * level)
-        str << (last_node ? "└" : "├")
-        str << "─"
-        str << (deps.empty? ? "─" : "┬")
-        str << " #{node[:text]}\n"
-
-        branch = format_tree(deps, level + 1)
-        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
-        str << branch
-      end
-
-      return str
-    end
-
-    def self.build_tree(mods, dir)
-      mods.each do |mod|
-        version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
-
-        if mod[:action] == :upgrade
-          previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
-          version_string = "#{previous_version} -> #{version_string}"
-        end
-
-        mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
-        mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
-
-        deps = (mod[:dependencies] || [])
-        deps.sort! { |a, b| a[:name] <=> b[:name] }
-        build_tree(deps, dir)
-      end
-    end
-
-    # @param options [Hash<Symbol,String>] This hash will contain any
-    #   command-line arguments that are not Settings, as those will have already
-    #   been extracted by the underlying application code.
-    #
-    # @note Unfortunately the whole point of this method is the side effect of
-    # modifying the options parameter.  This same hash is referenced both
-    # when_invoked and when_rendering.  For this reason, we are not returning
-    # a duplicate.
-    # @todo Validate the above note...
-    #
-    # An :environment_instance and a :target_dir are added/updated in the
-    # options parameter.
-    #
-    # @api private
-    def self.set_option_defaults(options)
-      current_environment = environment_from_options(options)
-
-      modulepath = [options[:target_dir]] + current_environment.full_modulepath
-
-      face_environment = current_environment.override_with(:modulepath => modulepath.compact)
-
-      options[:environment_instance] = face_environment
-
-      # Note: environment will have expanded the path
-      options[:target_dir] = face_environment.full_modulepath.first
-
-    end
-
-    # Given a hash of options, we should discover or create a
-    # {Puppet::Node::Environment} instance that reflects the provided options.
-    #
-    # Generally speaking, the `:modulepath` parameter should supersede all
-    # others, the `:environment` parameter should follow after that, and we
-    # should default to Puppet's current environment.
-    #
-    # @param options [{Symbol => Object}] the options to derive environment from
-    # @return [Puppet::Node::Environment] the environment described by the options
-    def self.environment_from_options(options)
-      if options[:modulepath]
-        path = options[:modulepath].split(File::PATH_SEPARATOR)
-        Puppet::Node::Environment.create(:anonymous, path, '')
-      elsif options[:environment].is_a?(Puppet::Node::Environment)
-        options[:environment]
-      elsif options[:environment]
-        # This use of looking up an environment is correct since it honours
-        # a request to get a particular environment via environment name.
-        Puppet.lookup(:environments).get!(options[:environment])
-      else
-        Puppet.lookup(:current_environment)
-      end
-    end
-
-    # Handles parsing of module dependency expressions into proper
-    # {SemanticPuppet::VersionRange}s, including reasonable error handling.
-    #
-    # @param where [String] a description of the thing we're parsing the
-    #        dependency expression for
-    # @param dep [Hash] the dependency description to parse
-    # @return [Array(String, SemanticPuppet::VersionRange, String)] a tuple of the
-    #         dependent module's name, the version range dependency, and the
-    #         unparsed range expression.
-    def self.parse_module_dependency(where, dep)
-      dep_name = dep['name'].tr('/', '-')
-      range = dep['version_requirement'] || '>= 0.0.0'
-
-      begin
-        parsed_range = Module.parse_range(range)
-      rescue ArgumentError => e
-        Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
-        parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE
-      end
-
-      [ dep_name, parsed_range, range ]
-    end
-  end
-end
-
-# Load remaining libraries
-require 'puppet/module_tool/errors'
-require 'puppet/module_tool/applications'
-require 'puppet/module_tool/checksums'
-require 'puppet/module_tool/contents_description'
-require 'puppet/module_tool/dependency'
-require 'puppet/module_tool/metadata'
-require 'puppet/forge/cache'
-require 'puppet/forge'