inspec 4.18.51 → 4.18.85

data/lib/inspec/control_eval_context.rb

@@ -1,248 +0,0 @@
-require "inspec/dsl"
-require "inspec/dsl_shared"
-require "rspec/core/dsl"
-
-module Inspec
-  #
-  # ControlEvalContext constructs an anonymous class that control
-  # files will be instance_exec'd against.
-  #
-  # The anonymous class includes the given passed resource_dsl as well
-  # as the basic DSL of the control files (describe, control, title,
-  # etc).
-  #
-  class ControlEvalContext
-    # Create the context for controls. This includes all components of the DSL,
-    # including matchers and resources.
-    #
-    # @param [ResourcesDSL] resources_dsl which has all resources to attach
-    # @return [RuleContext] the inner context of rules
-    def self.rule_context(resources_dsl, profile_id)
-      Class.new(Inspec::Rule) do
-        include RSpec::Core::DSL
-        with_resource_dsl resources_dsl
-
-        # allow attributes to be accessed within control blocks
-        define_method :input do |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
-
-        # Find the Input object, but don't collapse to a value.
-        # Will return nil on a miss.
-        define_method :input_object do |input_name|
-          Inspec::InputRegistry.find_or_register_input(input_name, profile_id)
-        end
-
-        define_method :attribute do |name, options = {}|
-          Inspec.deprecate(:attrs_dsl, "Input name: #{name}, Profile: #{profile_id}")
-          input(name, options)
-        end
-
-        # Support for Control DSL plugins.
-        # This is called when an unknown method is encountered
-        # within a control block.
-        def method_missing(method_name, *arguments, &block)
-          # Check to see if there is a control_dsl plugin activator hook with the method name
-          registry = Inspec::Plugin::V2::Registry.instance
-          hook = registry.find_activators(plugin_type: :control_dsl, activator_name: method_name).first
-          if hook
-            # OK, load the hook if it hasn't been already.  We'll then know a module,
-            # which we can then inject into the context
-            hook.activate
-
-            # Inject the module's methods into the context.
-            # implementation_class is the field name, but this is actually a module.
-            self.class.include(hook.implementation_class)
-            # Now that the module is loaded, it defined one or more methods
-            # (presumably the one we were looking for.)
-            # We still haven't called it, so do so now.
-            send(method_name, *arguments, &block)
-          else
-            begin
-              Inspec::DSL.method_missing_resource(inspec, method_name, *arguments)
-            rescue LoadError
-              super
-            end
-          end
-        end
-
-      end
-    end
-
-    # Creates the heart of the control eval context:
-    #
-    # An instantiated object which has all resources registered to it
-    # and exposes them to the a test file.
-    #
-    # @param profile_context [Inspec::ProfileContext]
-    # @param outer_dsl [OuterDSLClass]
-    # @return [ProfileContextClass]
-    def self.create(profile_context, resources_dsl) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      profile_context_owner = profile_context
-      profile_id = profile_context.profile_id
-      rule_class = rule_context(resources_dsl, profile_id)
-      Class.new do # rubocop:disable Metrics/BlockLength
-        include Inspec::DSL
-        include Inspec::DSL::RequireOverride
-        include resources_dsl
-
-        attr_accessor :skip_file
-
-        def initialize(backend, conf, dependencies, require_loader, skip_only_if_eval)
-          @backend = backend
-          @conf = conf
-          @dependencies = dependencies
-          @require_loader = require_loader
-          @skip_file_message = nil
-          @skip_file = false
-          @skip_only_if_eval = skip_only_if_eval
-        end
-
-        define_method :title do |arg|
-          profile_context_owner.set_header(:title, arg)
-        end
-
-        def to_s
-          "Control Evaluation Context (#{profile_name})"
-        end
-
-        define_method :profile_name do
-          profile_id
-        end
-
-        define_method :control do |*args, &block|
-          id = args[0]
-          opts = args[1] || {}
-          opts[:skip_only_if_eval] = @skip_only_if_eval
-          register_control(rule_class.new(id, profile_id, opts, &block))
-        end
-
-        #
-        # Describe allows users to write rspec-like bare describe
-        # blocks without declaring an inclosing control. Here, we
-        # generate a control for them automatically and then execute
-        # the describe block in the context of that control.
-        #
-        define_method :describe do |*args, &block|
-          loc = block_location(block, caller(1..1).first)
-          id = "(generated from #{loc} #{SecureRandom.hex})"
-
-          res = nil
-          rule = rule_class.new(id, profile_id, {}) do
-            res = describe(*args, &block)
-          end
-          register_control(rule, &block)
-
-          res
-        end
-
-        define_method :add_resource do |name, new_res|
-          resources_dsl.module_exec do
-            define_method name.to_sym do |*args|
-              new_res.new(@backend, name.to_s, *args)
-            end
-          end
-        end
-
-        define_method :add_resources do |context|
-          self.class.class_eval do
-            include context.to_resources_dsl
-          end
-
-          rule_class.class_eval do
-            include context.to_resources_dsl
-          end
-        end
-
-        define_method :add_subcontext do |context|
-          profile_context_owner.add_subcontext(context)
-        end
-
-        define_method :register_control do |control, &block|
-          if @skip_file
-            ::Inspec::Rule.set_skip_rule(control, true, @skip_file_message)
-          end
-
-          unless profile_context_owner.profile_supports_platform?
-            platform = inspec.platform
-            msg = "Profile `#{profile_context_owner.profile_id}` is not supported on platform #{platform.name}/#{platform.release}."
-            ::Inspec::Rule.set_skip_rule(control, true, msg)
-          end
-
-          unless profile_context_owner.profile_supports_inspec_version?
-            msg = "Profile `#{profile_context_owner.profile_id}` is not supported on InSpec version (#{Inspec::VERSION})."
-            ::Inspec::Rule.set_skip_rule(control, true, msg)
-          end
-
-          profile_context_owner.register_rule(control, &block) unless control.nil?
-        end
-
-        define_method :input do |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
-
-        # Find the Input object, but don't collapse to a value.
-        # Will return nil on a miss.
-        define_method :input_object do |input_name|
-          Inspec::InputRegistry.find_or_register_input(input_name, profile_id)
-        end
-
-        define_method :attribute do |name, options = {}|
-          Inspec.deprecate(:attrs_dsl, "Input name: #{name}, Profile: #{profile_id}")
-          input(name, options)
-        end
-
-        define_method :skip_control do |id|
-          profile_context_owner.unregister_rule(id)
-        end
-
-        define_method :only_if do |message = nil, &block|
-          return unless block
-          return if @skip_file == true
-          return if @skip_only_if_eval == true
-
-          return if block.yield == true
-
-          # Apply `set_skip_rule` for other rules in the same file
-          profile_context_owner.rules.values.each do |r|
-            sources_match = r.source_file == block.source_location[0]
-            Inspec::Rule.set_skip_rule(r, true, message) if sources_match
-          end
-
-          @skip_file_message = message
-          @skip_file = true
-        end
-
-        alias_method :rule, :control
-        alias_method :skip_rule, :skip_control
-
-        private
-
-        def block_location(block, alternate_caller)
-          if block.nil?
-            alternate_caller[/^(.+:\d+):in .+$/, 1] || "unknown"
-          else
-            path, line = block.source_location
-            "#{File.basename(path)}:#{line}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/inspec/dependencies/cache.rb

@@ -1,74 +0,0 @@
-require "fileutils"
-
-module Inspec
-  #
-  # Inspec::Cache manages an on-disk cache of inspec profiles.  The
-  # cache can contain:
-  #
-  #  - .tar.gz profile archives
-  #  - .zip profile archives
-  #  - unpacked profiles
-  #
-  # Cache entries names include a hash of their source to prevent
-  # conflicts between depenedencies with the same name from different
-  # sources.
-  #
-  #
-  class Cache
-    attr_reader :path
-    def initialize(path = nil)
-      @path = path || File.join(Inspec.config_dir, "cache")
-      FileUtils.mkdir_p(@path) unless File.directory?(@path)
-    rescue Errno::EACCES
-      # ignore
-    end
-
-    def prefered_entry_for(key)
-      path = base_path_for(key)
-      if File.directory?(path)
-        path
-      else
-        archive_entry_for(key)
-      end
-    end
-
-    def archive_entry_for(key)
-      path = base_path_for(key)
-      if File.exist?("#{path}.tar.gz")
-        "#{path}.tar.gz"
-      elsif File.exist?("#{path}.zip")
-        "#{path}.zip"
-      end
-    end
-
-    #
-    # For a given name and source_url, return true if the
-    # profile exists in the Cache.
-    #
-    # @param [String] name
-    # @param [String] source_url
-    # @return [Boolean]
-    #
-    def exists?(key)
-      return false if key.nil? || key.empty?
-
-      path = base_path_for(key)
-      File.directory?(path) || File.exist?("#{path}.tar.gz") || File.exist?("#{path}.zip")
-    end
-
-    #
-    # Return the path to given profile in the cache.
-    #
-    # The `source_url` parameter should be a URI-like string that
-    # fully specifies the source of the exact version we want to pull
-    # down.
-    #
-    # @param [String] name
-    # @param [String] source_url
-    # @return [String]
-    #
-    def base_path_for(cache_key)
-      File.join(@path, cache_key)
-    end
-  end
-end

data/lib/inspec/dependencies/dependency_set.rb

@@ -1,93 +0,0 @@
-require "inspec/dependencies/requirement"
-require "inspec/dependencies/resolver"
-
-module Inspec
-  #
-  # A DependencySet manages a list of dependencies for a profile.
-  #
-  class DependencySet
-    #
-    # Return a dependency set given a lockfile.
-    #
-    # @param lockfile [Inspec::Lockfile] A lockfile to generate the dependency set from
-    # @param cwd [String] Current working directory for relative path includes
-    # @param vendor_path [String] Path to the vendor directory
-    #
-    def self.from_lockfile(lockfile, config, opts = {})
-      dep_tree = lockfile.deps.map do |dep|
-        Inspec::Requirement.from_lock_entry(dep, config, opts)
-      end
-
-      dep_list = flatten_dep_tree(dep_tree)
-      new(config[:cwd], config[:cache], dep_list, config[:backend])
-    end
-
-    def self.from_array(dependencies, cwd, cache, backend)
-      dep_list = {}
-      dependencies.each do |d|
-        dep_list[d.name] = d
-      end
-      new(cwd, cache, dep_list, backend)
-    end
-
-    # This is experimental code to test the working of the
-    # dependency loader - perform a proper dependency related search
-    # in the future.
-    #
-    # Flatten tree because that is all we know how to deal with for
-    # right now. Last dep seen for a given name wins right now.
-    def self.flatten_dep_tree(dep_tree)
-      dep_list = {}
-      dep_tree.each do |d|
-        dep_list[d.name] = d
-        dep_list.merge!(flatten_dep_tree(d.dependencies))
-      end
-      dep_list
-    end
-
-    attr_reader :vendor_path
-    attr_accessor :dep_list
-    # initialize
-    #
-    # @param cwd [String] current working directory for relative path includes
-    # @param vendor_path [String] path which contains vendored dependencies
-    # @return [dependencies] this
-    def initialize(cwd, cache, dep_list, backend)
-      @cwd = cwd
-      @cache = cache
-      @dep_list = dep_list
-      @backend = backend
-    end
-
-    def each
-      @dep_list.each do |_k, v|
-        yield v.profile
-      end
-    end
-
-    def list
-      @dep_list || {}
-    end
-
-    def to_array
-      return [] if @dep_list.nil?
-
-      @dep_list.map do |_k, v|
-        v.to_hash
-      end.compact
-    end
-
-    #
-    # 1. Get dependencies, pull things to a local cache if necessary
-    # 2. Resolve dependencies
-    #
-    # @param dependencies [Gem::Dependency] list of dependencies
-    # @return [nil]
-    #
-    def vendor(dependencies)
-      return nil if dependencies.nil? || dependencies.empty?
-
-      @dep_list = Resolver.resolve(dependencies, @cache, @cwd, @backend)
-    end
-  end
-end

data/lib/inspec/dependencies/lockfile.rb

@@ -1,115 +0,0 @@
-require "yaml"
-
-module Inspec
-  class Lockfile
-    # When we finalize this feature, we should set these to 1
-    MINIMUM_SUPPORTED_VERSION = 1
-    CURRENT_LOCKFILE_VERSION = 1
-
-    def self.from_dependency_set(dep_set)
-      lockfile_content = {
-        "lockfile_version" => CURRENT_LOCKFILE_VERSION,
-        "depends" => dep_set.to_array,
-      }
-      new(lockfile_content)
-    end
-
-    def self.from_content(content)
-      parsed_content = YAML.load(content)
-      version = parsed_content["lockfile_version"]
-      raise "No lockfile_version set in #{path}!" if version.nil?
-
-      validate_lockfile_version!(version.to_i)
-      new(parsed_content)
-    end
-
-    def self.from_file(path)
-      content = File.read(path)
-      from_content(content)
-    end
-
-    def self.validate_lockfile_version!(version)
-      if version < MINIMUM_SUPPORTED_VERSION
-        raise <<~EOF
-          This lockfile specifies a lockfile_version of #{version} which is
-          lower than the minimum supported version #{MINIMUM_SUPPORTED_VERSION}.
-
-          Please create a new lockfile for this project by running:
-
-              inspec vendor
-        EOF
-      elsif version > CURRENT_LOCKFILE_VERSION
-        raise <<~EOF
-          This lockfile claims to be version #{version} which is greater than
-          the most recent lockfile version(#{CURRENT_LOCKFILE_VERSION}).
-
-          This may happen if you are using an older version of inspec than was
-          used to create the lockfile.
-        EOF
-      end
-    end
-
-    attr_reader :version, :deps
-    def initialize(lockfile_content_hash)
-      version = lockfile_content_hash["lockfile_version"]
-      @version = version.to_i
-      parse_content_hash(lockfile_content_hash)
-    end
-
-    def to_yaml
-      {
-        "lockfile_version" => CURRENT_LOCKFILE_VERSION,
-        "depends" => @deps.map { |i| stringify_keys(i) },
-      }.to_yaml
-    end
-
-    private
-
-    # Refactor this to be "version-wise" - i.e. make one dispatch
-    # function for each version so that even if it duplicates code,
-    # it can describe the part of the code that it expects to be
-    # different. Then that dispatch routine can call more well
-    # defined methods like "parse_v0_dependencies" or
-    # "parse_flat_dependencies" or what not as things generally
-    # develop. It does help people easily set breakpoints/track
-    # different entry points of the API.
-    def parse_content_hash(lockfile_content_hash)
-      case version
-      when 1
-        parse_content_hash_1(lockfile_content_hash)
-      else
-        # If we've gotten here, there is likely a mistake in the
-        # lockfile version validation in the constructor.
-        raise "No lockfile parser for version #{version}"
-      end
-    end
-
-    def parse_content_hash_1(lockfile_content_hash)
-      @deps = lockfile_content_hash["depends"]&.map { |i| symbolize_keys(i) }
-    end
-
-    def mutate_hash_keys_with(hash, fun)
-      hash.each_with_object({}) do |v, memo|
-        key = fun.call(v[0])
-        value = if v[1].is_a?(Hash)
-                  mutate_hash_keys_with(v[1], fun)
-                elsif v[1].is_a?(Array)
-                  v[1].map do |i|
-                    i.is_a?(Hash) ? mutate_hash_keys_with(i, fun) : i
-                  end
-                else
-                  v[1]
-                end
-        memo[key] = value
-      end
-    end
-
-    def stringify_keys(hash)
-      mutate_hash_keys_with(hash, proc { |i| i.to_s })
-    end
-
-    def symbolize_keys(hash)
-      mutate_hash_keys_with(hash, proc { |i| i.to_sym })
-    end
-  end
-end