bolt 0.24.0 → 0.25.0

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

@@ -1,49 +0,0 @@
-require 'digest/md5'
-require 'puppet/network/format_support'
-
-module Puppet::ModuleTool
-
-  # = Checksums
-  #
-  # This class provides methods for generating checksums for data and adding
-  # them to +Metadata+.
-  class Checksums
-    include Puppet::Network::FormatSupport
-    include Enumerable
-
-    # Instantiate object with string +path+ to create checksums from.
-    def initialize(path)
-      @path = Pathname.new(path)
-    end
-
-    # Return checksum for the +Pathname+.
-    def checksum(pathname)
-      return Digest::MD5.hexdigest(Puppet::FileSystem.binread(pathname))
-    end
-
-    # Return checksums for object's +Pathname+, generate if it's needed.
-    # Result is a hash of path strings to checksum strings.
-    def data
-      unless @data
-        @data = {}
-        @path.find do |descendant|
-          if Puppet::ModuleTool.artifact?(descendant)
-            Find.prune
-          elsif descendant.file?
-            path = descendant.relative_path_from(@path)
-            @data[path.to_s] = checksum(descendant)
-          end
-        end
-      end
-      return @data
-    end
-
-    alias :to_data_hash :data
-    alias :to_hash :data
-
-    # TODO: Why?
-    def each(&block)
-      data.each(&block)
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-require 'puppet/module_tool'
-
-module Puppet::ModuleTool
-
-  # = ContentsDescription
-  #
-  # This class populates +Metadata+'s Puppet type information.
-  class ContentsDescription
-
-    # Instantiate object for string +module_path+.
-    def initialize(module_path)
-      @module_path = module_path
-    end
-
-    # Update +Metadata+'s Puppet type information.
-    def annotate(metadata)
-      metadata.types.replace data.clone
-    end
-
-    # Return types for this module. Result is an array of hashes, each of which
-    # describes a Puppet type. The type description hash structure is:
-    # * :name => Name of this Puppet type.
-    # * :doc => Documentation for this type.
-    # * :properties => Array of hashes representing the type's properties, each
-    #   containing :name and :doc.
-    # * :parameters => Array of hashes representing the type's parameters, each
-    #   containing :name and :doc.
-    # * :providers => Array of hashes representing the types providers, each
-    #   containing :name and :doc.
-    # TODO Write a TypeDescription to encapsulate these structures and logic?
-    def data
-      unless @data
-        @data = []
-        type_names = []
-        for module_filename in Dir[File.join(@module_path, "lib/puppet/type/*.rb")]
-          require module_filename
-          type_name = File.basename(module_filename, ".rb")
-          type_names << type_name
-
-          for provider_filename in Dir[File.join(@module_path, "lib/puppet/provider/#{type_name}/*.rb")]
-            require provider_filename
-          end
-        end
-
-        type_names.each do |name|
-          if type = Puppet::Type.type(name.to_sym)
-            type_hash = {:name => name, :doc => type.doc}
-            type_hash[:properties] = attr_doc(type, :property)
-            type_hash[:parameters] = attr_doc(type, :param)
-            if type.providers.size > 0
-              type_hash[:providers] = provider_doc(type)
-            end
-            @data << type_hash
-          else
-            Puppet.warning _("Could not find/load type: %{name}") % { name: name }
-          end
-        end
-      end
-      @data
-    end
-
-    # Return an array of hashes representing this +type+'s attrs of +kind+
-    # (e.g. :param or :property), each containing :name and :doc.
-    def attr_doc(type, kind)
-      attrs = []
-
-      type.allattrs.each do |name|
-        if type.attrtype(name) == kind && name != :provider
-          attrs.push(:name => name, :doc => type.attrclass(name).doc)
-        end
-      end
-
-      attrs
-    end
-
-    # Return an array of hashes representing this +type+'s providers, each
-    # containing :name and :doc.
-    def provider_doc(type)
-      providers = []
-
-      type.providers.sort.each do |prov|
-        providers.push(:name => prov, :doc => type.provider(prov).doc)
-      end
-
-      providers
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'puppet/module_tool'
-require 'puppet/network/format_support'
-
-module Puppet::ModuleTool
-
-  class Dependency
-    include Puppet::Network::FormatSupport
-
-    attr_reader :full_module_name, :username, :name, :version_requirement, :repository
-
-    # Instantiates a new module dependency with a +full_module_name+ (e.g.
-    # "myuser-mymodule"), and optional +version_requirement+ (e.g. "0.0.1") and
-    # optional repository (a URL string).
-    def initialize(full_module_name, version_requirement = nil, repository = nil)
-      @full_module_name = full_module_name
-      # TODO: add error checking, the next line raises ArgumentError when +full_module_name+ is invalid
-      @username, @name = Puppet::ModuleTool.username_and_modname_from(full_module_name)
-      @version_requirement = version_requirement
-      @repository = repository ? Puppet::Forge::Repository.new(repository, nil) : nil
-    end
-
-    # We override Object's ==, eql, and hash so we can more easily find identical
-    # dependencies.
-    def ==(o)
-      self.hash == o.hash
-    end
-
-    alias :eql? :==
-
-    def hash
-      [@full_module_name, @version_requirement, @repository].hash
-    end
-
-    def to_data_hash
-      result = { :name => @full_module_name }
-      result[:version_requirement] = @version_requirement if @version_requirement && ! @version_requirement.nil?
-      result[:repository] = @repository.to_s if @repository && ! @repository.nil?
-      result
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'puppet/module_tool'
-
-module Puppet::ModuleTool
-  module Errors
-    require 'puppet/module_tool/errors/base'
-    require 'puppet/module_tool/errors/installer'
-    require 'puppet/module_tool/errors/uninstaller'
-    require 'puppet/module_tool/errors/upgrader'
-    require 'puppet/module_tool/errors/shared'
-  end
-end

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

@@ -1,15 +0,0 @@
-module Puppet::ModuleTool::Errors
-  class ModuleToolError < Puppet::Error
-    def v(version)
-      (version || '???').to_s.sub(/^(?=\d)/, 'v')
-    end
-
-    def vstring
-      if @action == :upgrade
-        "#{v(@installed_version)} -> #{v(@requested_version)}"
-      else
-        "#{v(@installed_version || @requested_version)}"
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-module Puppet::ModuleTool::Errors
-
-  class InstallError < ModuleToolError; end
-
-  class AlreadyInstalledError < InstallError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @installed_version = v(options[:installed_version])
-      @requested_version = v(options[:requested_version])
-      @local_changes     = options[:local_changes]
-      super _("'%{module_name}' (%{version}) requested; '%{module_name}' (%{installed_version}) already installed") % { module_name: @module_name, version: @requested_version, installed_version: @installed_version }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @module_name, version: @requested_version }
-      message << _("  Module '%{module_name}' (%{installed_version}) is already installed") % { module_name: @module_name, installed_version: @installed_version }
-      message << _("    Installed module has had changes made locally") unless @local_changes.empty?
-      #TRANSLATORS `puppet module upgrade` is a command line and should not be translated
-      message << _("    Use `puppet module upgrade` to install a different version")
-      #TRANSLATORS `puppet module install --force` is a command line and should not be translated
-      message << _("    Use `puppet module install --force` to re-install only this module")
-      message.join("\n")
-    end
-  end
-
-  class MissingPackageError < InstallError
-    def initialize(options)
-      @requested_package = options[:requested_package]
-      @source = options[:source]
-
-      super _("Could not install '%{requested_package}'; no releases are available from %{source}") % { requested_package: @requested_package, source: @source }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not install '%{requested_package}'") % { requested_package: @requested_package }
-      message << _("  No releases are available from %{source}") % { source: @source }
-      message << _("    Does '%{requested_package}' have at least one published release?") % { requested_package: @requested_package }
-      message.join("\n")
-    end
-  end
-
-  class InstallPathExistsNotDirectoryError < InstallError
-    def initialize(original, options)
-      @requested_module  = options[:requested_module]
-      @requested_version = options[:requested_version]
-      @directory         = options[:directory]
-      super(_("'%{module_name}' (%{version}) requested; Path %{dir} is not a directory.") % { module_name: @requested_module, version: @requested_version, dir: @directory }, original)
-    end
-
-    def multiline
-      message = []
-      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
-      message << _("  Path '%{directory}' exists but is not a directory.") % { directory: @directory }
-      #TRANSLATORS "mkdir -p '%{directory}'" is a command line example and should not be translated
-      message << _("  A potential solution is to rename the path and then \"mkdir -p '%{directory}'\"") % { directory: @directory }
-      message.join("\n")
-    end
-  end
-
-  class PermissionDeniedCreateInstallDirectoryError < InstallError
-    def initialize(original, options)
-      @requested_module  = options[:requested_module]
-      @requested_version = options[:requested_version]
-      @directory         = options[:directory]
-      super(_("'%{module_name}' (%{version}) requested; Permission is denied to create %{dir}.") % { module_name: @requested_module, version: @requested_version, dir: @directory }, original)
-    end
-
-    def multiline
-      message = []
-      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
-      message << _("  Permission is denied when trying to create directory '%{directory}'.")  % { directory: @directory }
-      message << _('  A potential solution is to check the ownership and permissions of parent directories.')
-      message.join("\n")
-    end
-  end
-
-  class InvalidPathInPackageError < InstallError
-    def initialize(options)
-      @entry_path = options[:entry_path]
-      @directory  = options[:directory]
-      super _("Attempt to install file with an invalid path into %{path} under %{dir}") % { path: @entry_path.inspect, dir: @directory.inspect }
-    end
-
-    def multiline
-      message = []
-      message << _('Could not install package with an invalid path.')
-      message << _('  Package attempted to install file into %{path} under %{directory}.') % { path: @entry_path.inspect, directory: @directory.inspect }
-      message.join("\n")
-    end
-  end
-end

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

@@ -1,195 +0,0 @@
-module Puppet::ModuleTool::Errors
-
-  class NoVersionsSatisfyError < ModuleToolError
-    def initialize(options)
-      @requested_name    = options[:requested_name]
-      @requested_version = options[:requested_version]
-      @installed_version = options[:installed_version]
-      @conditions        = options[:conditions]
-      @action            = options[:action]
-
-      super _("Could not %{action} '%{module_name}' (%{version}); no version satisfies all dependencies") % { action: @action, module_name: @requested_name, version: vstring }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @requested_name, version: vstring }
-      message << _("  No version of '%{module_name}' can satisfy all dependencies") % { module_name: @requested_name }
-      #TRANSLATORS `puppet module %{action} --ignore-dependencies` is a command line and should not be translated
-      message << _("    Use `puppet module %{action} --ignore-dependencies` to %{action} only this module") % { action: @action }
-      message.join("\n")
-    end
-  end
-
-  class NoCandidateReleasesError < ModuleToolError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @requested_version = options[:requested_version]
-      @installed_version = options[:installed_version]
-      @source            = options[:source]
-      @action            = options[:action]
-
-      if @requested_version == :latest
-        super _("Could not %{action} '%{module_name}'; no releases are available from %{source}") % { action: @action, module_name: @module_name, source: @source }
-      else
-        super _("Could not %{action} '%{module_name}'; no releases matching '%{version}' are available from %{source}") % { action: @action, module_name: @module_name, version: @requested_version, source: @source }
-      end
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
-      if @requested_version == :latest
-        message << _("  No releases are available from %{source}") % { source: @source }
-        message << _("    Does '%{module_name}' have at least one published release?") % { module_name: @module_name }
-      else
-        message << _("  No releases matching '%{requested_version}' are available from %{source}") % { requested_version: @requested_version, source: @source }
-      end
-      message.join("\n")
-    end
-  end
-
-  class InstallConflictError < ModuleToolError
-    def initialize(options)
-      @requested_module  = options[:requested_module]
-      @requested_version = v(options[:requested_version])
-      @dependency        = options[:dependency]
-      @directory         = options[:directory]
-      @metadata          = options[:metadata]
-      super _("'%{module_name}' (%{version}) requested; installation conflict") % { module_name: @requested_module, version: @requested_version }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
-
-      if @dependency
-        message << _("  Dependency '%{name}' (%{version}) would overwrite %{directory}") % { name: @dependency[:name], version: v(@dependency[:version]), directory: @directory }
-      else
-        message << _("  Installation would overwrite %{directory}") % { directory: @directory }
-      end
-
-      if @metadata
-        message << _("    Currently, '%{current_name}' (%{current_version}) is installed to that directory") % { current_name: @metadata["name"], current_version: v(@metadata["version"]) }
-      end
-
-      if @dependency
-        #TRANSLATORS `puppet module install --ignore-dependencies` is a command line and should not be translated
-        message << _("    Use `puppet module install --ignore-dependencies` to install only this module")
-      else
-        #TRANSLATORS `puppet module install --force` is a command line and should not be translated
-        message << _("    Use `puppet module install --force` to install this module anyway")
-      end
-      message.join("\n")
-    end
-  end
-
-  class InvalidDependencyCycleError < ModuleToolError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @requested_module  = options[:requested_module]
-      @requested_version = options[:requested_version]
-      @conditions        = options[:conditions]
-      @source            = options[:source][1..-1]
-
-      super _("'%{module_name}' (%{version}) requested; Invalid dependency cycle") % { module_name: @requested_module, version: v(@requested_version) }
-    end
-
-    def multiline
-      dependency_list = []
-      dependency_list << _("You specified '%{name}' (%{version})") % { name: @source.first[:name], version: v(@requested_version) }
-      dependency_list += @source[1..-1].map do |m|
-        #TRANSLATORS This message repeats as separate lines as a list under the heading "You specified '%{name}' (%{version})\n"
-        _("This depends on '%{name}' (%{version})") % { name: m[:name], version: v(m[:version]) }
-      end
-      message = []
-      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: v(@requested_version) }
-      message << _("  No version of '%{module_name}' will satisfy dependencies") % { module_name: @module_name }
-      message << dependency_list.map {|s| "    #{s}".join(",\n")}
-      #TRANSLATORS `puppet module install --force` is a command line and should not be translated
-      message << _("    Use `puppet module install --force` to install this module anyway")
-      message.join("\n")
-    end
-  end
-
-  class NotInstalledError < ModuleToolError
-    def initialize(options)
-      @module_name = options[:module_name]
-      @suggestions = options[:suggestions] || []
-      @action      = options[:action]
-      super _("Could not %{action} '%{module_name}'; module is not installed") % { action: @action, module_name: @module_name }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
-      message << _("  Module '%{module_name}' is not installed") % { module_name: @module_name }
-      message += @suggestions.map do |suggestion|
-        #TRANSLATORS `puppet module %{action} %{suggestion}` is a command line and should not be translated
-        _("    You may have meant `puppet module %{action} %{suggestion}`") % { action: @action, suggestion: suggestion }
-      end
-      #TRANSLATORS `puppet module install` is a command line and should not be translated
-      message << _("    Use `puppet module install` to install this module") if @action == :upgrade
-      message.join("\n")
-    end
-  end
-
-  class MultipleInstalledError < ModuleToolError
-    def initialize(options)
-      @module_name = options[:module_name]
-      @modules     = options[:installed_modules]
-      @action      = options[:action]
-      #TRANSLATORS "module path" refers to a set of directories where modules may be installed
-      super _("Could not %{action} '%{module_name}'; module appears in multiple places in the module path") % { action: @action, module_name: @module_name }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
-      message << _("  Module '%{module_name}' appears multiple places in the module path") % { module_name: @module_name }
-      message += @modules.map do |mod|
-        #TRANSLATORS This is repeats as separate lines as a list under "Module '%{module_name}' appears multiple places in the module path"
-        _("    '%{module_name}' (%{version}) was found in %{path}") % { module_name: @module_name, version: v(mod.version), path: mod.modulepath }
-      end
-      #TRANSLATORS `--modulepath` is command line option and should not be translated
-      message << _("    Use the `--modulepath` option to limit the search to specific directories")
-      message.join("\n")
-    end
-  end
-
-  class LocalChangesError < ModuleToolError
-    def initialize(options)
-      @module_name       = options[:module_name]
-      @requested_version = options[:requested_version]
-      @installed_version = options[:installed_version]
-      @action            = options[:action]
-      super _("Could not %{action} '%{module_name}'; module has had changes made locally") % { action: @action, module_name: @module_name }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
-      message << _("  Installed module has had changes made locally")
-      #TRANSLATORS `puppet module %{action} --ignore-changes` is a command line and should not be translated
-      message << _("    Use `puppet module %{action} --ignore-changes` to %{action} this module anyway") % { action: @action }
-      message.join("\n")
-    end
-  end
-
-  class InvalidModuleError < ModuleToolError
-    def initialize(name, options)
-      @name   = name
-      @action = options[:action]
-      @error  = options[:error]
-      super _("Could not %{action} '%{module_name}'; %{error}") % { action: @action, module_name: @name, error: @error.message }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @name }
-      message << _("  Failure trying to parse metadata")
-      message << _("    Original message was: %{message}") % { message: @error.message }
-      message.join("\n")
-    end
-  end
-end