bolt 0.19.1 → 0.20.0

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

@@ -1,45 +0,0 @@
-require 'puppet/module_tool'
-require 'puppet/module_tool/errors'
-
-module Puppet
-  module ModuleTool
-    # Control the install location for modules.
-    class InstallDirectory
-      include Puppet::ModuleTool::Errors
-
-      attr_reader :target
-      def initialize(target)
-        @target = target
-      end
-
-      # prepare the module install location. This will create the location if
-      # needed.
-      def prepare(module_name, version)
-        return if @target.directory?
-
-        begin
-          @target.mkpath
-          Puppet.notice _("Created target directory %{dir}") % { dir: @target }
-        rescue SystemCallError => orig_error
-          raise converted_to_friendly_error(module_name, version, orig_error)
-        end
-      end
-
-    private
-
-      ERROR_MAPPINGS = {
-        Errno::EACCES => PermissionDeniedCreateInstallDirectoryError,
-        Errno::EEXIST => InstallPathExistsNotDirectoryError,
-      }
-
-      def converted_to_friendly_error(module_name, version, orig_error)
-        return orig_error if not ERROR_MAPPINGS.include?(orig_error.class)
-
-        ERROR_MAPPINGS[orig_error.class].new(orig_error,
-          :requested_module  => module_name,
-          :requested_version => version,
-          :directory         => @target.to_s)
-      end
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-require 'pathname'
-
-require 'puppet/forge'
-require 'puppet/module_tool'
-
-module Puppet::ModuleTool
-  class InstalledModules < SemanticPuppet::Dependency::Source
-    attr_reader :modules, :by_name
-
-    def priority
-      10
-    end
-
-    def initialize(env)
-      @env = env
-      modules = env.modules_by_path
-
-      @fetched = []
-      @modules = {}
-      @by_name = {}
-      env.modulepath.each do |path|
-        modules[path].each do |mod|
-          @by_name[mod.name] = mod
-          next unless mod.has_metadata?
-          release = ModuleRelease.new(self, mod)
-          @modules[release.name] ||= release
-        end
-      end
-
-      @modules.freeze
-    end
-
-    # Fetches {ModuleRelease} entries for each release of the named module.
-    #
-    # @param name [String] the module name to look up
-    # @return [Array<SemanticPuppet::Dependency::ModuleRelease>] a list of releases for
-    #         the given name
-    # @see SemanticPuppet::Dependency::Source#fetch
-    def fetch(name)
-      name = name.tr('/', '-')
-
-      if @modules.key? name
-        @fetched << name
-        [ @modules[name] ]
-      else
-        [ ]
-      end
-    end
-
-    def fetched
-      @fetched
-    end
-
-    class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
-      attr_reader :mod, :metadata
-
-      def initialize(source, mod, strict_semver = true)
-        @mod = mod
-        @metadata = mod.metadata
-        name = mod.forge_name.tr('/', '-')
-        begin
-          version = SemanticPuppet::Version.parse(mod.version)
-        rescue SemanticPuppet::Version::ValidationFailure
-          Puppet.warning _("%{module_name} (%{path}) has an invalid version number (%{version}). The version has been set to 0.0.0. If you are the maintainer for this module, please update the metadata.json with a valid Semantic Version (http://semver.org).") % { module_name: mod.name, path: mod.path, version: mod.version }
-          version = SemanticPuppet::Version.parse("0.0.0")
-        end
-        release = "#{name}@#{version}"
-
-        super(source, name, version, {})
-
-        if mod.dependencies
-          mod.dependencies.each do |dependency|
-            results = Puppet::ModuleTool.parse_module_dependency(release, dependency, strict_semver)
-            dep_name, parsed_range, range = results
-
-            add_constraint('initialize', dep_name, range.to_s) do |node|
-              parsed_range === node.version
-            end
-          end
-        end
-      end
-
-      def install_dir
-        Pathname.new(@mod.path).dirname
-      end
-
-      def install(dir)
-        # If we're already installed, there's no need for us to faff about.
-      end
-
-      def prepare
-        # We're already installed; what preparation remains?
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-require 'pathname'
-require 'tmpdir'
-
-require 'puppet/forge'
-require 'puppet/module_tool'
-
-module Puppet::ModuleTool
-  class LocalTarball < SemanticPuppet::Dependency::Source
-    attr_accessor :release
-
-    def initialize(filename, strict_semver = true)
-      unpack(filename, tmpdir)
-      Puppet.debug "Unpacked local tarball to #{tmpdir}"
-
-      mod = Puppet::Module.new('tarball', tmpdir, nil, strict_semver)
-      @release = ModuleRelease.new(self, mod)
-    end
-
-    def fetch(name)
-      if @release.name == name
-        [ @release ]
-      else
-        [ ]
-      end
-    end
-
-    def prepare(release)
-      release.mod.path
-    end
-
-    def install(release, dir)
-      staging_dir = release.prepare
-
-      module_dir = dir + release.name[/-(.*)/, 1]
-      module_dir.rmtree if module_dir.exist?
-
-      # Make sure unpacked module has the same ownership as the folder we are moving it into.
-      Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
-
-      FileUtils.mv(staging_dir, module_dir)
-    end
-
-    class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
-      attr_reader :mod, :install_dir, :metadata
-
-      def initialize(source, mod)
-        @mod = mod
-        @metadata = mod.metadata
-        name = mod.forge_name.tr('/', '-')
-        version = SemanticPuppet::Version.parse(mod.version)
-        release = "#{name}@#{version}"
-
-        if mod.dependencies
-          dependencies = mod.dependencies.map do |dep|
-            Puppet::ModuleTool.parse_module_dependency(release, dep, mod.strict_semver?)[0..1]
-          end
-          dependencies = Hash[dependencies]
-        end
-
-        super(source, name, version, dependencies || {})
-      end
-
-      def install(dir)
-        @source.install(self, dir)
-        @install_dir = dir
-      end
-
-      def prepare
-        @source.prepare(self)
-      end
-    end
-
-    private
-
-    # Obtain a suitable temporary path for unpacking tarballs
-    #
-    # @return [String] path to temporary unpacking location
-    def tmpdir
-      @dir ||= Dir.mktmpdir('local-tarball', Puppet::Forge::Cache.base_path)
-    end
-
-    def unpack(file, destination)
-      begin
-        Puppet::ModuleTool::Applications::Unpacker.unpack(file, destination)
-      rescue Puppet::ExecutionFailure => e
-        raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
-      end
-    end
-  end
-end

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

@@ -1,223 +0,0 @@
-require 'puppet/util/methodhelper'
-require 'puppet/module_tool'
-require 'puppet/network/format_support'
-require 'uri'
-require 'json'
-require 'set'
-
-module Puppet::ModuleTool
-
-  # This class provides a data structure representing a module's metadata.
-  # @api private
-  class Metadata
-    include Puppet::Network::FormatSupport
-
-    attr_accessor :module_name
-
-    DEFAULTS = {
-      'name'          => nil,
-      'version'       => nil,
-      'author'        => nil,
-      'summary'       => nil,
-      'license'       => 'Apache-2.0',
-      'source'        => '',
-      'project_page'  => nil,
-      'issues_url'    => nil,
-      'dependencies'  => Set.new.freeze,
-      'data_provider' => nil,
-    }
-
-    def initialize
-      @data = DEFAULTS.dup
-      @data['dependencies'] = @data['dependencies'].dup
-    end
-
-    # Returns a filesystem-friendly version of this module name.
-    def dashed_name
-      @data['name'].tr('/', '-') if @data['name']
-    end
-
-    # Returns a string that uniquely represents this version of this module.
-    def release_name
-      return nil unless @data['name'] && @data['version']
-      [ dashed_name, @data['version'] ].join('-')
-    end
-
-    alias :name :module_name
-    alias :full_module_name :dashed_name
-
-    # Merges the current set of metadata with another metadata hash.  This
-    # method also handles the validation of module names and versions, in an
-    # effort to be proactive about module publishing constraints.
-    def update(data)
-      process_name(data) if data['name']
-      process_version(data) if data['version']
-      process_source(data) if data['source']
-      process_data_provider(data) if data['data_provider']
-      merge_dependencies(data) if data['dependencies']
-
-      @data.merge!(data)
-      return self
-    end
-
-    # Validates the name and version_requirement for a dependency, then creates
-    # the Dependency and adds it.
-    # Returns the Dependency that was added.
-    def add_dependency(name, version_requirement=nil, repository=nil)
-      validate_name(name)
-      validate_version_range(version_requirement) if version_requirement
-
-      if dup = @data['dependencies'].find { |d| d.full_module_name == name && d.version_requirement != version_requirement }
-        raise ArgumentError, _("Dependency conflict for %{module_name}: Dependency %{name} was given conflicting version requirements %{version_requirement} and %{dup_version}. Verify that there are no duplicates in the metadata.json.") % { module_name: full_module_name, name: name, version_requirement: version_requirement, dup_version: dup.version_requirement }
-      end
-
-      dep = Dependency.new(name, version_requirement, repository)
-      @data['dependencies'].add(dep)
-
-      dep
-    end
-
-    # Provides an accessor for the now defunct 'description' property.  This
-    # addresses a regression in Puppet 3.6.x where previously valid templates
-    # referring to the 'description' property were broken.
-    # @deprecated
-    def description
-      @data['description']
-    end
-
-    def dependencies
-      @data['dependencies'].to_a
-    end
-
-    # Returns a hash of the module's metadata.  Used by Puppet's automated
-    # serialization routines.
-    #
-    # @see Puppet::Network::FormatSupport#to_data_hash
-    def to_hash
-      @data
-    end
-    alias :to_data_hash :to_hash
-
-    def to_json
-      data = @data.dup.merge('dependencies' => dependencies)
-
-      contents = data.keys.map do |k|
-        value = (JSON.pretty_generate(data[k]) rescue data[k].to_json)
-        "#{k.to_json}: #{value}"
-      end
-
-      "{\n" + contents.join(",\n").gsub(/^/, '  ') + "\n}\n"
-    end
-
-    # Expose any metadata keys as callable reader methods.
-    def method_missing(name, *args)
-      return @data[name.to_s] if @data.key? name.to_s
-      super
-    end
-
-    private
-
-    # Do basic validation and parsing of the name parameter.
-    def process_name(data)
-      validate_name(data['name'])
-      author, @module_name = data['name'].split(/[-\/]/, 2)
-
-      data['author'] ||= author if @data['author'] == DEFAULTS['author']
-    end
-
-    # Do basic validation on the version parameter.
-    def process_version(data)
-      validate_version(data['version'])
-    end
-
-    def process_data_provider(data)
-      validate_data_provider(data['data_provider'])
-    end
-
-    # Do basic parsing of the source parameter.  If the source is hosted on
-    # GitHub, we can predict sensible defaults for both project_page and
-    # issues_url.
-    def process_source(data)
-      if data['source'] =~ %r[://]
-        source_uri = URI.parse(data['source'])
-      else
-        source_uri = URI.parse("http://#{data['source']}")
-      end
-
-      if source_uri.host =~ /^(www\.)?github\.com$/
-        source_uri.scheme = 'https'
-        source_uri.path.sub!(/\.git$/, '')
-        data['project_page'] ||= @data['project_page'] || source_uri.to_s
-        data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
-      end
-
-    rescue URI::Error
-      return
-    end
-
-    # Validates and parses the dependencies.
-    def merge_dependencies(data)
-      data['dependencies'].each do |dep|
-        add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
-      end
-
-      # Clear dependencies so @data dependencies are not overwritten
-      data.delete 'dependencies'
-    end
-
-    # Validates that the given module name is both namespaced and well-formed.
-    def validate_name(name)
-      return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
-
-      namespace, modname = name.split(/[-\/]/, 2)
-      modname = :namespace_missing if namespace == ''
-
-      err = case modname
-      when nil, '', :namespace_missing
-        _("the field must be a namespaced module name")
-      when /[^a-z0-9_]/i
-        _("the module name contains non-alphanumeric (or underscore) characters")
-      when /^[^a-z]/i
-        _("the module name must begin with a letter")
-      else
-        _("the namespace contains non-alphanumeric characters")
-      end
-
-      raise ArgumentError, _("Invalid 'name' field in metadata.json: %{err}") % { err: err }
-    end
-
-    # Validates that the version string can be parsed as per SemVer.
-    def validate_version(version)
-      return if SemanticPuppet::Version.valid?(version)
-
-      err = _("version string cannot be parsed as a valid Semantic Version")
-      raise ArgumentError, _("Invalid 'version' field in metadata.json: %{err}") % { err: err }
-    end
-
-    # Validates that the given _value_ is a symbolic name that starts with a letter
-    # and then contains only letters, digits, or underscore. Will raise an ArgumentError
-    # if that's not the case.
-    #
-    # @param value [Object] The value to be tested
-    def validate_data_provider(value)
-      if value.is_a?(String)
-        unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
-          if value =~ /^[a-zA-Z]/
-            raise ArgumentError, _("field 'data_provider' contains non-alphanumeric characters")
-          else
-            raise ArgumentError, _("field 'data_provider' must begin with a letter")
-          end
-        end
-      else
-        raise ArgumentError, _("field 'data_provider' must be a string")
-      end
-    end
-
-    # Validates that the version range can be parsed by Semantic.
-    def validate_version_range(version_range)
-      SemanticPuppet::VersionRange.parse(version_range)
-    rescue ArgumentError => e
-      raise ArgumentError, _("Invalid 'version_range' field in metadata.json: %{err}") % { err: e }
-    end
-  end
-end