inspec 4.18.51 → 4.18.85

data/lib/inspec/input_dsl_helpers.rb

@@ -1,26 +0,0 @@
-
-require "inspec/input_registry"
-
-module Inspec
-  # A mixin to provide implementations for the input() DSL methods
-  module InputDslHelpers
-
-    # Find or create an input, explicitly named by a profile ID and
-    #  input name. Evaluate the input and return the value.
-    # @param [String] Profile ID
-    # @param [String] Input Name
-    # @param [Hash] Input options - see input docs on website
-    # @returns [Object] Input value
-    def input_with_profile_id(profile_id, input_name, options)
-      if options.empty?
-        # Simply an access, no event here
-        Inspec::InputRegistry.find_or_register_input(input_name, profile_id).value
-      else
-        options[:priority] = 20
-        options[:provider] = :inline_control_code
-        evt = Inspec::Input.infer_event(options)
-        Inspec::InputRegistry.find_or_register_input(input_name, profile_id, event: evt).value
-      end
-    end
-  end
-end

data/lib/inspec/input_registry.rb

@@ -1,315 +0,0 @@
-require "forwardable"
-require "singleton"
-require "inspec/input"
-require "inspec/secrets"
-require "inspec/exceptions"
-require "inspec/plugin/v2"
-
-module Inspec
-  # The InputRegistry's responsibilities include:
-  #   - maintaining a list of Input objects that are bound to profiles
-  #   - assisting in the lookup and creation of Inputs
-  class InputRegistry
-    include Singleton
-    extend Forwardable
-
-    class Error < Inspec::Error; end
-    class ProfileLookupError < Error
-      attr_accessor :profile_name
-    end
-    class InputLookupError < Error
-      attr_accessor :profile_name
-      attr_accessor :input_name
-    end
-
-    attr_reader :inputs_by_profile, :profile_aliases, :plugins
-    def_delegator :inputs_by_profile, :each
-    def_delegator :inputs_by_profile, :[]
-    def_delegator :inputs_by_profile, :key?, :profile_known?
-    def_delegator :inputs_by_profile, :select
-    def_delegator :profile_aliases, :key?, :profile_alias?
-
-    def initialize
-      # Keyed on String profile_name => Hash of String input_name => Input object
-      @inputs_by_profile = {}
-
-      # this is a list of optional profile name overrides set in the inspec.yml
-      @profile_aliases = {}
-
-      # Upon creation, activate all input plugins
-      activators = Inspec::Plugin::V2::Registry.instance.find_activators(plugin_type: :input)
-
-      @plugins = activators.map do |activator|
-        activator.activate!
-        activator.implementation_class.new
-      end
-    end
-
-    #-------------------------------------------------------------#
-    #                 Support for Profiles
-    #-------------------------------------------------------------#
-
-    def register_profile_alias(name, alias_name)
-      @profile_aliases[name] = alias_name
-    end
-
-    # Returns an Hash, name => Input that have actually been mentioned
-    def list_inputs_for_profile(profile)
-      inputs_by_profile[profile] = {} unless profile_known?(profile)
-      inputs_by_profile[profile]
-    end
-
-    # Returns an Array of input names. This includes input names
-    # that plugins may be able to fetch, but have not actually been
-    # mentioned in the control code.
-    def list_potential_input_names_for_profile(profile_name)
-      input_names_from_dsl = inputs_by_profile[profile_name].keys
-      input_names_from_plugins = plugins.map { |plugin| plugin.list_inputs(profile_name) }
-      (input_names_from_dsl + input_names_from_plugins).flatten.uniq
-    end
-
-    #-------------------------------------------------------------#
-    #              Support for Individual Inputs
-    #-------------------------------------------------------------#
-
-    def find_or_register_input(input_name, profile_name, options = {})
-      input_name = input_name.to_s
-      profile_name = profile_name.to_s
-
-      if profile_alias?(profile_name) && !profile_aliases[profile_name].nil?
-        alias_name = profile_name
-        profile_name = profile_aliases[profile_name]
-        handle_late_arriving_alias(alias_name, profile_name) if profile_known?(alias_name)
-      end
-
-      # Find or create the input
-      inputs_by_profile[profile_name] ||= {}
-      if inputs_by_profile[profile_name].key?(input_name)
-        inputs_by_profile[profile_name][input_name].update(options)
-      else
-        inputs_by_profile[profile_name][input_name] = Inspec::Input.new(input_name, options)
-        poll_plugins_for_update(profile_name, input_name)
-      end
-
-      inputs_by_profile[profile_name][input_name]
-    end
-
-    def poll_plugins_for_update(profile_name, input_name)
-      plugins.each do |plugin|
-        response = plugin.fetch(profile_name, input_name)
-        evt = Inspec::Input::Event.new(
-          action: :fetch,
-          provider: plugin.class.plugin_name,
-          priority: plugin.default_priority,
-          hit: !response.nil?
-        )
-        evt.value = response unless response.nil?
-        inputs_by_profile[profile_name][input_name].events << evt
-      end
-    end
-
-    # It is possible for a wrapper profile to create an input in metadata,
-    # referring to the child profile by an alias that has not yet been registered.
-    # The registry will then store the inputs under the alias, as if the alias
-    # were a true profile.
-    # If that happens and the child profile also mentions the input, we will
-    # need to move some things - all inputs should be stored under the true
-    # profile name, and no inputs should be stored under the alias.
-    def handle_late_arriving_alias(alias_name, profile_name)
-      inputs_by_profile[profile_name] ||= {}
-      inputs_by_profile[alias_name].each do |input_name, input_from_alias|
-        # Move the inpuut, or if it exists, merge events
-        existing = inputs_by_profile[profile_name][input_name]
-        if existing
-          existing.events.concat(input_from_alias.events)
-        else
-          inputs_by_profile[profile_name][input_name] = input_from_alias
-        end
-      end
-      # Finally, delete the (now copied-out) entry for the alias
-      inputs_by_profile.delete(alias_name)
-    end
-    #-------------------------------------------------------------#
-    #               Support for Binding Inputs
-    #-------------------------------------------------------------#
-
-    # This method is called by the Profile as soon as it has
-    # enough context to allow binding inputs to it.
-    def bind_profile_inputs(profile_name, sources = {})
-      inputs_by_profile[profile_name] ||= {}
-
-      # In a more perfect world, we could let the core plugins choose
-      # self-determine what to do; but as-is, the APIs that call this
-      # are a bit over-constrained.
-      bind_inputs_from_metadata(profile_name, sources[:profile_metadata])
-      bind_inputs_from_input_files(profile_name, sources[:cli_input_files])
-      bind_inputs_from_runner_api(profile_name, sources[:runner_api])
-      bind_inputs_from_cli_args(profile_name, sources[:cli_input_arg])
-    end
-
-    private
-
-    def bind_inputs_from_cli_args(profile_name, input_list)
-      # TODO: move this into a core plugin
-
-      return if input_list.nil?
-      return if input_list.empty?
-
-      # These arrive as an array of "name=value" strings
-      # If the user used a comma, we'll see unfortunately see it as "name=value," pairs
-      input_list.each do |pair|
-        unless pair.include?("=")
-          if pair.end_with?(".yaml")
-            raise ArgumentError, "ERROR: --input is used for individual input values, as --input name=value. Use --input-file to load a YAML file."
-          else
-            raise ArgumentError, "ERROR: An '=' is required when using --input. Usage: --input input_name1=input_value1 input2=value2"
-          end
-        end
-        input_name, input_value = pair.split("=")
-        evt = Inspec::Input::Event.new(
-          value: input_value.chomp(","), # Trim trailing comma if any
-          provider: :cli,
-          priority: 50
-        )
-        find_or_register_input(input_name, profile_name, event: evt)
-      end
-    end
-
-    def bind_inputs_from_runner_api(profile_name, input_hash)
-      # TODO: move this into a core plugin
-
-      return if input_hash.nil?
-      return if input_hash.empty?
-
-      # These arrive as a bare hash - values are raw values, not options
-      input_hash.each do |input_name, input_value|
-        loc = Inspec::Input::Event.probe_stack # TODO: likely modify this to look for a kitchen.yml, if that is realistic
-        evt = Inspec::Input::Event.new(
-          value: input_value,
-          provider: :runner_api, # TODO: suss out if audit cookbook or kitchen-inspec or something unknown
-          priority: 40,
-          file: loc.path,
-          line: loc.lineno
-        )
-        find_or_register_input(input_name, profile_name, event: evt)
-      end
-    end
-
-    def bind_inputs_from_input_files(profile_name, file_list)
-      # TODO: move this into a core plugin
-
-      return if file_list.nil?
-      return if file_list.empty?
-
-      file_list.each do |path|
-        validate_inputs_file_readability!(path)
-
-        # TODO: drop this SecretsBackend stuff, will be handled by plugin system
-        data = Inspec::SecretsBackend.resolve(path)
-        if data.nil?
-          raise Inspec::Exceptions::SecretsBackendNotFound,
-                "Cannot find parser for inputs file '#{path}'. " \
-                "Check to make sure file has the appropriate extension."
-        end
-
-        next if data.inputs.nil?
-
-        data.inputs.each do |input_name, input_value|
-          evt = Inspec::Input::Event.new(
-            value: input_value,
-            provider: :cli_files,
-            priority: 40,
-            file: path
-            # TODO: any way we could get a line number?
-          )
-          find_or_register_input(input_name, profile_name, event: evt)
-        end
-      end
-    end
-
-    def validate_inputs_file_readability!(path)
-      unless File.exist?(path)
-        raise Inspec::Exceptions::InputsFileDoesNotExist,
-              "Cannot find input file '#{path}'. " \
-              "Check to make sure file exists."
-      end
-
-      unless File.readable?(path)
-        raise Inspec::Exceptions::InputsFileNotReadable,
-              "Cannot read input file '#{path}'. " \
-              "Check to make sure file is readable."
-      end
-
-      true
-    end
-
-    def bind_inputs_from_metadata(profile_name, profile_metadata_obj)
-      # TODO: move this into a core plugin
-      return if profile_metadata_obj.nil? # Metadata files are technically optional
-
-      if profile_metadata_obj.params.key?(:inputs)
-        raw_inputs = profile_metadata_obj.params[:inputs]
-      elsif profile_metadata_obj.params.key?(:attributes)
-        Inspec.deprecate(:attrs_rename_in_metadata, "Profile: '#{profile_name}'.")
-        raw_inputs = profile_metadata_obj.params[:attributes]
-      else
-        return
-      end
-
-      unless raw_inputs.is_a?(Array)
-        Inspec::Log.warn "Inputs must be defined as an Array in metadata files. Skipping definition from #{profile_name}."
-        return
-      end
-
-      raw_inputs.each { |i| handle_raw_input_from_metadata(i, profile_name) }
-    end
-
-    def handle_raw_input_from_metadata(input_orig, profile_name)
-      input_options = input_orig.dup
-      input_name = input_options.delete(:name)
-      input_options[:provider] = :profile_metadata
-      input_options[:file] = File.join(profile_name, "inspec.yml")
-      input_options[:priority] ||= 30
-      evt = Inspec::Input.infer_event(input_options)
-
-      # Profile metadata may set inputs in other profiles by naming them.
-      if input_options[:profile]
-        profile_name = input_options[:profile] || profile_name
-        # Override priority to force this to win.  Allow user to set their own priority.
-        evt.priority = input_orig[:priority] || 35
-      end
-      find_or_register_input(
-        input_name,
-        profile_name,
-        type: input_options[:type],
-        required: input_options[:required],
-        event: evt
-      )
-    end
-
-    #-------------------------------------------------------------#
-    #               Other Support
-    #-------------------------------------------------------------#
-    public
-
-    # Used in testing
-    def __reset
-      @inputs_by_profile = {}
-      @profile_aliases = {}
-    end
-
-    # These class methods are convenience methods so you don't always
-    # have to call #instance when calling the registry
-    %i{
-      find_or_register_input
-      register_profile_alias
-      list_inputs_for_profile
-      list_potential_input_names_for_profile
-      bind_profile_inputs
-    }.each do |meth|
-      define_singleton_method(meth) do |*args|
-        instance.send(meth, *args)
-      end
-    end
-  end
-end

data/lib/inspec/library_eval_context.rb

@@ -1,55 +0,0 @@
-require "inspec/plugin/v1/plugin_types/resource"
-require "inspec/dsl_shared"
-
-module Inspec
-  #
-  # LibaryEvalContext constructs an instance of an anonymous class
-  # that library files will be instance_exec'd against.
-  #
-  # The anonymous class ensures that `Inspec.resource(1)` will return
-  # an anonymouse class that is suitable as the parent class of an
-  # inspec resource. The class returned will have the resource
-  # registry used by all dsl methods bound to the resource registry
-  # passed into the #create constructor.
-  #
-  #
-  class LibraryEvalContext
-    def self.create(registry, require_loader)
-      c = Class.new do
-        extend Inspec::ResourceDSL
-        include Inspec::ResourceBehaviors
-        define_singleton_method :__resource_registry do
-          registry
-        end
-      end
-
-      c2 = Class.new do
-        define_singleton_method :resource do |version|
-          Inspec.validate_resource_dsl_version!(version)
-          c
-        end
-      end
-
-      c3 = Class.new do
-        include Inspec::DSL::RequireOverride
-        def initialize(require_loader)
-          @require_loader = require_loader
-          @inspec_binding = nil
-        end
-
-        def __inspec_binding
-          @inspec_binding
-        end
-      end
-
-      c3.const_set(:Inspec, c2)
-      res = c3.new(require_loader)
-
-      # Provide the local binding for this context which is necessary for
-      # calls to `require` to create all dependent objects in the correct
-      # context.
-      res.instance_variable_set("@inspec_binding", res.instance_eval("binding"))
-      res
-    end
-  end
-end

data/lib/inspec/log.rb

@@ -1,7 +0,0 @@
-require "mixlib/log"
-
-module Inspec
-  class Log
-    extend Mixlib::Log
-  end
-end

data/lib/inspec/metadata.rb

@@ -1,253 +0,0 @@
-# Copyright 2015 Dominik Richter
-
-require "logger"
-require "rubygems/version"
-require "rubygems/requirement"
-require "semverse"
-
-require "inspec/version"
-require "inspec/utils/spdx"
-
-module Inspec
-  # Extract metadata.rb information
-  # A Metadata object may be created and finalized with invalid data.
-  # This allows the check CLI command to analyse the issues.
-  # Use valid? to determine if the metadata is coherent.
-  class Metadata
-    attr_reader :ref
-    attr_accessor :params, :content
-    def initialize(ref, logger = nil)
-      @ref = ref
-      @logger = logger || Logger.new(nil)
-      @content = ""
-      @params = {}
-      @missing_methods = []
-    end
-
-    %w{
-      name
-      title
-      maintainer
-      maintainer_email
-      copyright
-      copyright_email
-      license
-      summary
-      description
-      version
-      inspec_version
-    }.each do |name|
-      define_method name.to_sym do |arg|
-        params[name.to_sym] = arg
-      end
-    end
-
-    def dependencies
-      params[:depends] || []
-    end
-
-    def supports(sth, version = nil)
-      # Ignore supports with metadata.rb. This file is legacy and the way it
-      # it handles `supports` deprecated. A deprecation warning will be printed
-      # already.
-    end
-
-    def inspec_requirement
-      # using Gem::Requirement here to allow nil values which
-      # translate to [">= 0"]
-      Gem::Requirement.create(params[:inspec_version])
-    end
-
-    def supports_runtime?
-      running = Gem::Version.new(Inspec::VERSION)
-      inspec_requirement.satisfied_by?(running)
-    end
-
-    def supports_platform?(backend)
-      require "inspec/resources/platform" # break circularity in load
-      backend.platform.supported?(params[:supports])
-    end
-
-    # return all warn and errors
-    def valid # rubocop:disable Metrics/AbcSize
-      errors = []
-      warnings = []
-
-      %w{name version}.each do |field|
-        next unless params[field.to_sym].nil?
-
-        errors.push("Missing profile #{field} in #{ref}")
-      end
-
-      if %r{[\/\\]} =~ params[:name]
-        errors.push("The profile name (#{params[:name]}) contains a slash" \
-                      " which is not permitted. Please remove all slashes from `inspec.yml`.")
-      end
-
-      # if version is set, ensure it is correct
-      if !params[:version].nil? && !valid_version?(params[:version])
-        errors.push("Version needs to be in SemVer format")
-      end
-
-      unless supports_runtime?
-        warnings.push("The current inspec version #{Inspec::VERSION} cannot satisfy profile inspec_version constraint #{params[:inspec_version]}")
-      end
-
-      %w{title summary maintainer copyright license}.each do |field|
-        next unless params[field.to_sym].nil?
-
-        warnings.push("Missing profile #{field} in #{ref}")
-      end
-
-      # if license is set, ensure it is in SPDX format or marked as proprietary
-      if !params[:license].nil? && !valid_license?(params[:license])
-        warnings.push("License '#{params[:license]}' needs to be in SPDX format or marked as 'Proprietary'. See https://spdx.org/licenses/.")
-      end
-
-      [errors, warnings]
-    end
-
-    # returns true or false
-    def valid?
-      errors, _warnings = valid
-      errors.empty? && unsupported.empty?
-    end
-
-    def valid_version?(value)
-      Semverse::Version.new(value)
-      true
-    rescue Semverse::InvalidVersionFormat
-      false
-    end
-
-    def valid_license?(value)
-      value =~ /^Proprietary[,;]?\b/ || Spdx.valid_license?(value)
-    end
-
-    def method_missing(sth, *args)
-      @logger.warn "#{ref} doesn't support: #{sth} #{args}"
-      @missing_methods.push(sth)
-    end
-
-    def unsupported
-      @missing_methods
-    end
-
-    def self.symbolize_keys(obj)
-      return obj.map { |i| symbolize_keys(i) } if obj.is_a?(Array)
-      return obj unless obj.is_a?(Hash)
-
-      obj.each_with_object({}) do |(k, v), h|
-        v = symbolize_keys(v) if v.is_a?(Hash)
-        v = symbolize_keys(v) if v.is_a?(Array)
-        h[k.to_sym] = v
-      end
-    end
-
-    def self.finalize_supports_elem(elem, logger)
-      case x = elem
-      when Hash
-        x[:release] = x[:release].to_s if x[:release]
-        x
-      when Array
-        logger.warn(
-          "Failed to read supports entry that is an array. Please use "\
-          "the `supports: {os-family: xyz}` syntax."
-        )
-        nil
-      when nil then nil
-      else
-        Inspec.deprecate(
-          :supports_syntax,
-          "Do not use deprecated `supports: #{x}` syntax. Instead use:\n"\
-            "supports:\n  - os-family: #{x}\n\n"
-        )
-
-        { :'os-family' => x } # rubocop:disable Style/HashSyntax
-      end
-    end
-
-    def self.finalize_supports(supports, logger)
-      case x = supports
-      when Hash   then [finalize_supports_elem(x, logger)]
-      when Array  then x.map { |e| finalize_supports_elem(e, logger) }.compact
-      when nil    then []
-      end
-    end
-
-    def self.finalize_name(metadata, profile_id, original_target)
-      # profile_id always overwrites whatever already exists as the name
-      unless profile_id.to_s.empty?
-        metadata.params[:name] = profile_id.to_s
-        return
-      end
-
-      # don't overwrite an existing name
-      return unless metadata.params[:name].nil?
-
-      # if there's a title, there is no need to set a name too
-      return unless metadata.params[:title].nil?
-
-      # create a new name based on the original target if it exists
-      # Crudely slug the target to not contain slashes, to avoid breaking
-      # unit tests that look for warning sequences
-      return if original_target.to_s.empty?
-
-      metadata.params[:title] = "tests from #{original_target}"
-      metadata.params[:name] = metadata.params[:title].gsub(%r{[\/\\]}, ".")
-    end
-
-    def self.finalize(metadata, profile_id, options, logger = nil)
-      return nil if metadata.nil?
-
-      param = metadata.params || {}
-      options ||= {}
-      param["version"] = param["version"].to_s unless param["version"].nil?
-      metadata.params = symbolize_keys(param)
-      metadata.params[:supports] = finalize_supports(metadata.params[:supports], logger)
-      finalize_name(metadata, profile_id, options[:target])
-
-      metadata
-    end
-
-    def self.from_yaml(ref, content, profile_id, logger = nil)
-      require "erb"
-      res = Metadata.new(ref, logger)
-      res.params = YAML.load(ERB.new(content).result)
-      res.content = content
-      finalize(res, profile_id, {}, logger)
-    end
-
-    def self.from_ruby(ref, content, profile_id, logger = nil)
-      res = Metadata.new(ref, logger)
-      res.instance_eval(content, ref, 1)
-      res.content = content
-      finalize(res, profile_id, {}, logger)
-    end
-
-    def self.from_ref(ref, content, profile_id, logger = nil)
-      # NOTE there doesn't have to exist an actual file, it may come from an
-      # archive (i.e., content)
-      case File.basename(ref)
-      when "inspec.yml"
-        from_yaml(ref, content, profile_id, logger)
-      when "metadata.rb"
-        from_ruby(ref, content, profile_id, logger)
-      else
-        logger ||= Logger.new(nil)
-        logger.error "Don't know how to handle metadata in #{ref}"
-        nil
-      end
-    end
-
-    def self.from_file(path, profile_id, logger = nil)
-      unless File.file?(path)
-        logger ||= Logger.new(nil)
-        logger.error "Can't find metadata file #{path}"
-        return nil
-      end
-
-      from_ref(File.basename(path), File.read(path), profile_id, logger)
-    end
-  end
-end