puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/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 < Semantic::Dependency::Source
-    attr_accessor :release
-
-    def initialize(filename)
-      unpack(filename, tmpdir)
-      Puppet.debug "Unpacked local tarball to #{tmpdir}"
-
-      mod = Puppet::Module.new('tarball', tmpdir, nil)
-      @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 < Semantic::Dependency::ModuleRelease
-      attr_reader :mod, :install_dir, :metadata
-
-      def initialize(source, mod)
-        @mod = mod
-        @metadata = mod.metadata
-        name = mod.forge_name.tr('/', '-')
-        version = Semantic::Version.parse(mod.version)
-        release = "#{name}@#{version}"
-
-        if mod.dependencies
-          dependencies = mod.dependencies.map do |dep|
-            Puppet::ModuleTool.parse_module_dependency(release, dep)[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: #{e.message}"
-      end
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/module_tool/metadata.rb

@@ -1,221 +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 #{full_module_name}: Dependency #{name} was given conflicting version requirements #{version_requirement} and #{dup.version_requirement}. Verify that there are no duplicates in the metadata.json."
-      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
-    # refering 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}"
-    end
-
-    # Validates that the version string can be parsed as per SemVer.
-    def validate_version(version)
-      return if SemVer.valid?(version)
-
-      err = "version string cannot be parsed as a valid Semantic Version"
-      raise ArgumentError, "Invalid 'version' field in metadata.json: #{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)
-      err = nil
-      if value.is_a?(String)
-        unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
-          err = value =~ /^[a-zA-Z]/ ? 'contains non-alphanumeric characters' : 'must begin with a letter'
-        end
-      else
-        err = 'must be a string'
-      end
-      raise ArgumentError, "field 'data_provider' #{err}" if err
-    end
-
-    # Validates that the version range can be parsed by Semantic.
-    def validate_version_range(version_range)
-      Semantic::VersionRange.parse(version_range)
-    rescue ArgumentError => e
-      raise ArgumentError, "Invalid 'version_range' field in metadata.json: #{e}"
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/module_tool/skeleton/templates/generator/examples/init.pp.erb

@@ -1,12 +0,0 @@
-# The baseline for module testing used by Puppet Labs is that each manifest
-# should have a corresponding test manifest that declares that class or defined
-# type.
-#
-# Tests are then run by using puppet apply --noop (to check for compilation
-# errors and view a log of events) or by fully applying the test in a virtual
-# environment (to compare the resulting system state to the desired state).
-#
-# Learn more about module testing here:
-# https://docs.puppet.com/guides/tests_smoke.html
-#
-include ::<%= metadata.name %>

data/vendor/gems/puppet-4.5.2/lib/puppet/module_tool/tar.rb

@@ -1,17 +0,0 @@
-require 'puppet/module_tool'
-require 'puppet/util'
-
-module Puppet::ModuleTool::Tar
-  require 'puppet/module_tool/tar/gnu'
-  require 'puppet/module_tool/tar/mini'
-
-  def self.instance
-    if Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
-      Gnu.new
-    elsif Puppet.features.minitar? && Puppet.features.zlib?
-      Mini.new
-    else
-      raise RuntimeError, 'No suitable tar implementation found'
-    end
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/network/http/api/indirected_routes.rb

@@ -1,248 +0,0 @@
-require 'puppet/network/authorization'
-require 'puppet/network/http/api/indirection_type'
-
-class Puppet::Network::HTTP::API::IndirectedRoutes
-  include Puppet::Network::Authorization
-
-  # How we map http methods and the indirection name in the URI
-  # to an indirection method.
-  METHOD_MAP = {
-    "GET" => {
-      :plural => :search,
-      :singular => :find
-    },
-    "POST" => {
-      :singular => :find,
-    },
-    "PUT" => {
-      :singular => :save
-    },
-    "DELETE" => {
-      :singular => :destroy
-    },
-    "HEAD" => {
-      :singular => :head
-    }
-  }
-
-  IndirectionType = Puppet::Network::HTTP::API::IndirectionType
-
-  def self.routes
-    Puppet::Network::HTTP::Route.path(/.*/).any(new)
-  end
-
-  # handle an HTTP request
-  def call(request, response)
-    indirection, method, key, params = uri2indirection(request.method, request.path, request.params)
-    certificate = request.client_cert
-
-    if !indirection.allow_remote_requests?
-      # TODO: should we tell the user we found an indirection but it doesn't
-      # allow remote requests, or just pretend there's no handler at all? what
-      # are the security implications for the former?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No handler for #{indirection.name}", :NO_INDIRECTION_REMOTE_REQUESTS)
-    end
-
-    trusted = Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate)
-    Puppet.override(:trusted_information => trusted) do
-      send("do_#{method}", indirection, key, params, request, response)
-    end
-  rescue Puppet::Network::HTTP::Error::HTTPError => e
-    return do_http_control_exception(response, e)
-  rescue StandardError => e
-    return do_exception(response, e)
-  end
-
-  def uri2indirection(http_method, uri, params)
-    # the first field is always nil because of the leading slash,
-    indirection_type, version, indirection_name, key = uri.split("/", 5)[1..-1]
-    url_prefix = "/#{indirection_type}/#{version}"
-    environment = params.delete(:environment)
-
-    if indirection_name !~ /^\w+$/
-      raise ArgumentError, "The indirection name must be purely alphanumeric, not '#{indirection_name}'"
-    end
-
-    # this also depluralizes the indirection_name if it is a search
-    method = indirection_method(http_method, indirection_name)
-
-    # check whether this indirection matches the prefix and version in the
-    # request
-    if url_prefix != IndirectionType.url_prefix_for(indirection_name)
-      raise ArgumentError, "Indirection '#{indirection_name}' does not match url prefix '#{url_prefix}'"
-    end
-
-    indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
-    if !indirection
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        "Could not find indirection '#{indirection_name}'", Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
-    end
-
-    if !environment
-      raise ArgumentError, "An environment parameter must be specified"
-    end
-
-    if ! Puppet::Node::Environment.valid_name?(environment)
-      raise ArgumentError, "The environment must be purely alphanumeric, not '#{environment}'"
-    end
-
-    configured_environment = Puppet.lookup(:environments).get(environment)
-    unless configured_environment.nil?
-      configured_environment = configured_environment.override_from_commandline(Puppet.settings)
-      params[:environment] = configured_environment
-    end
-
-    check_authorization(method, "#{url_prefix}/#{indirection_name}/#{key}", params)
-
-    if configured_environment.nil?
-      raise ArgumentError, "Could not find environment '#{environment}'"
-    end
-
-    params.delete(:bucket_path)
-
-    if key == "" or key.nil?
-      raise ArgumentError, "No request key specified in #{uri}"
-    end
-
-    [indirection, method, key, params]
-  end
-
-  private
-
-  def do_http_control_exception(response, exception)
-    msg = exception.message
-    Puppet.info(msg)
-    response.respond_with(exception.status, "text/plain", msg)
-  end
-
-  def do_exception(response, exception, status=400)
-    if exception.is_a?(Puppet::Network::AuthorizationError)
-      # make sure we return the correct status code
-      # for authorization issues
-      status = 403 if status == 400
-    end
-
-    Puppet.log_exception(exception)
-
-    response.respond_with(status, "text/plain", exception.to_s)
-  end
-
-  # Execute our find.
-  def do_find(indirection, key, params, request, response)
-    unless result = indirection.find(key, params)
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
-    end
-
-    format = accepted_response_formatter_for(indirection.model, request)
-
-    rendered_result = result
-    if result.respond_to?(:render)
-      Puppet::Util::Profiler.profile("Rendered result in #{format}", [:http, :v3_render, format]) do
-        rendered_result = result.render(format)
-      end
-    end
-
-    Puppet::Util::Profiler.profile("Sent response", [:http, :v3_response]) do
-      response.respond_with(200, format, rendered_result)
-    end
-  end
-
-  # Execute our head.
-  def do_head(indirection, key, params, request, response)
-    unless indirection.head(key, params)
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
-    end
-
-    # No need to set a response because no response is expected from a
-    # HEAD request.  All we need to do is not die.
-  end
-
-  # Execute our search.
-  def do_search(indirection, key, params, request, response)
-    result = indirection.search(key, params)
-
-    if result.nil?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find instances in #{indirection.name} with '#{key}'", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
-    end
-
-    format = accepted_response_formatter_for(indirection.model, request)
-
-    response.respond_with(200, format, indirection.model.render_multiple(format, result))
-  end
-
-  # Execute our destroy.
-  def do_destroy(indirection, key, params, request, response)
-    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
-
-    result = indirection.destroy(key, params)
-
-    response.respond_with(200, formatter, formatter.render(result))
-  end
-
-  # Execute our save.
-  def do_save(indirection, key, params, request, response)
-    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
-    sent_object = read_body_into_model(indirection.model, request)
-
-    result = indirection.save(sent_object, key)
-
-    response.respond_with(200, formatter, formatter.render(result))
-  end
-
-  def accepted_response_formatter_for(model_class, request)
-    accepted_formats = request.headers['accept'] or raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("Missing required Accept header", Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
-    request.response_formatter_for(model_class.supported_formats, accepted_formats)
-  end
-
-  def accepted_response_formatter_or_pson_for(model_class, request)
-    accepted_formats = request.headers['accept'] || "text/pson"
-    request.response_formatter_for(model_class.supported_formats, accepted_formats)
-  end
-
-  def read_body_into_model(model_class, request)
-    data = request.body.to_s
-
-    format = request.format
-    model_class.convert_from(format, data)
-  end
-
-  def indirection_method(http_method, indirection)
-    raise ArgumentError, "No support for http method #{http_method}" unless METHOD_MAP[http_method]
-
-    unless method = METHOD_MAP[http_method][plurality(indirection)]
-      raise ArgumentError, "No support for plurality #{plurality(indirection)} for #{http_method} operations"
-    end
-
-    method
-  end
-
-  def self.request_to_uri(request)
-    uri, body = request_to_uri_and_body(request)
-    "#{uri}?#{body}"
-  end
-
-  def self.request_to_uri_and_body(request)
-    url_prefix = IndirectionType.url_prefix_for(request.indirection_name.to_s)
-    indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
-    ["#{url_prefix}/#{indirection}/#{request.escaped_key}", "environment=#{request.environment.name}&#{request.query_string}"]
-  end
-
-  def self.pluralize(indirection)
-    return(indirection == "status" ? "statuses" : indirection + "s")
-  end
-
-  def plurality(indirection)
-    # NOTE These specific hooks for paths are ridiculous, but it's a *many*-line
-    # fix to not need this, and our goal is to move away from the complication
-    # that leads to the fix being too long.
-    return :singular if indirection == "status"
-    return :singular if indirection == "certificate_status"
-
-    result = (indirection =~ /s$|_search$/) ? :plural : :singular
-
-    indirection.sub!(/s$|_search$/, '')
-    indirection.sub!(/statuse$/, 'status')
-
-    result
-  end
-end