inspec 4.18.51 → 4.18.85

data/lib/inspec/errors.rb

@@ -1,18 +0,0 @@
-module Inspec
-  class Error < StandardError; end
-
-  # dependency resolution
-  class CyclicDependencyError < Error; end
-  class UnsatisfiedVersionSpecification < Error; end
-  class DuplicateDep < Error; end
-  class FetcherFailure < Error; end
-  class ReporterError < Error; end
-  class ImpactError < Error; end
-
-  # Config file loading
-  class ConfigError < Error; end
-  class ConfigError::MalformedJson < ConfigError; end
-  class ConfigError::Invalid < ConfigError; end
-
-  class UserInteractionRequired < Error; end
-end

data/lib/inspec/exceptions.rb

@@ -1,11 +0,0 @@
-# copyright: 2017, Chef Software Inc.
-
-module Inspec
-  module Exceptions
-    class InputsFileDoesNotExist < ArgumentError; end
-    class InputsFileNotReadable < ArgumentError; end
-    class ResourceFailed < StandardError; end
-    class ResourceSkipped < StandardError; end
-    class SecretsBackendNotFound < ArgumentError; end
-  end
-end

data/lib/inspec/expect.rb

@@ -1,42 +0,0 @@
-# copyright: 2016, Chef Software Inc.
-
-require "rspec/expectations"
-
-module Inspec
-  class Expect
-    attr_reader :calls, :value, :block
-    def initialize(value, &block)
-      @value = value
-      @block = block
-      @calls = []
-    end
-
-    def to(*args, &block)
-      @calls.push([:to, args, block, caller])
-    end
-
-    def not_to(*args, &block)
-      @calls.push([:not_to, args, block, caller])
-    end
-
-    def example_group
-      that = self
-
-      opts = { "caller" => calls[0][3] } # TODO: this needs overhaul. no magic #s
-      if !calls[0][3].nil? && !calls[0][3].empty? &&
-          (m = calls[0][3][0].match(/^([^:]*):(\d+):/))
-        opts["file_path"] = m[0]
-        opts["line_number"] = m[1]
-      end
-
-      RSpec::Core::ExampleGroup.describe(that.value, opts) do
-        that.calls.each do |method, args, block, clr|
-          it(nil, caller: clr) do
-            x = expect(that.value, &that.block).method(method)
-            x.call(*args, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/inspec/fetcher.rb

@@ -1,48 +0,0 @@
-require "inspec/plugin/v1"
-
-module Inspec
-  class FetcherRegistry < PluginRegistry
-    def resolve(target)
-      if fetcher_specified?(target)
-        super(target)
-      else
-        Inspec::Log.debug("Assuming default supermarket source for #{target}")
-        super(with_default_fetcher(target))
-      end
-    end
-
-    NON_FETCHER_KEYS = %i{name version_constraint cwd backend cache sha256}.freeze
-    def fetcher_specified?(target)
-      # Only set a default for Hash-based (i.e. from
-      # inspec.yml/inspec.lock) targets
-
-      return true unless target.respond_to?(:keys)
-
-      !(target.keys - NON_FETCHER_KEYS).empty?
-    end
-
-    def with_default_fetcher(target)
-      target.merge({ supermarket: target[:name] })
-    end
-  end
-
-  module Fetcher
-    Registry = FetcherRegistry.new
-  end
-
-  def self.fetcher(version)
-    if version != 1
-      raise "Only fetcher version 1 is supported!"
-    end
-
-    Inspec::Plugins::Fetcher
-  end
-end
-
-# TODO: remove. require up, not down.
-require "inspec/fetcher/local"
-require "inspec/fetcher/url"
-require "inspec/fetcher/git"
-
-# TODO: Remove in 4.0 when Compliance fetcher plugin is created
-require "plugins/inspec-compliance/lib/inspec-compliance/api"

data/lib/inspec/fetcher/git.rb

@@ -1,211 +0,0 @@
-require "tmpdir"
-require "fileutils"
-require "mixlib/shellout"
-require "inspec/log"
-
-module Inspec::Fetcher
-  #
-  # The git fetcher uses the git binary to fetch remote git sources.
-  # Git-based sources should be specified with the `git:` key in the
-  # source hash. Additionally, we accept `:branch`, `:ref`, and `:tag`
-  # keys to allow users to pin to a particular revision.
-  #
-  # Parts of this class are derived from:
-  #
-  #  https://github.com/chef/omnibus/blob/master/lib/omnibus/fetchers/git_fetcher.rb
-  #
-  # which is Copyright 2012-2014 Chef Software, Inc. and offered under
-  # the same Apache 2 software license as inspec.
-  #
-  # Many thanks to the omnibus authors!
-  #
-  # Note that we haven't replicated all of omnibus' features here.  If
-  # you got to this file during debugging, you may want to look at the
-  # omnibus source for hints.
-  #
-  class Git < Inspec.fetcher(1)
-    name "git"
-    priority 200
-
-    def self.resolve(target, opts = {})
-      if target.is_a?(String)
-        new(target, opts) if target.start_with?("git@") || target.end_with?(".git")
-      elsif target.respond_to?(:has_key?) && target.key?(:git)
-        new(target[:git], opts.merge(target))
-      end
-    end
-
-    def initialize(remote_url, opts = {})
-      @branch = opts[:branch]
-      @tag = opts[:tag]
-      @ref = opts[:ref]
-      @remote_url = expand_local_path(remote_url)
-      @repo_directory = nil
-      @relative_path = opts[:relative_path] if opts[:relative_path] && !opts[:relative_path].empty?
-    end
-
-    def expand_local_path(url_or_file_path)
-      # This paths to local on-disk repos, not relative paths within repos.
-      # This is especially needed with testing.
-
-      # We could try to do something clever with URI
-      # processing, but then again, if you passed a relative path
-      # to an on-disk repo, you probably expect it to exist.
-      return url_or_file_path unless File.exist?(url_or_file_path)
-
-      # It's important to expand this path, because it may be specified
-      # locally in the metadata files, and when we clone, we will be
-      # in a temp dir.
-      File.expand_path(url_or_file_path)
-    end
-
-    def fetch(destination_path)
-      @repo_directory = destination_path # Might be the cache, or vendoring, or something else
-      FileUtils.mkdir_p(destination_path) unless Dir.exist?(destination_path)
-
-      if cloned?
-        checkout
-      else
-        Dir.mktmpdir do |working_dir|
-          checkout(working_dir)
-          if @relative_path
-            perform_relative_path_fetch(destination_path, working_dir)
-          else
-            Inspec::Log.debug("Checkout of #{resolved_ref} successful. " \
-                              "Moving checkout to #{destination_path}")
-            FileUtils.cp_r(working_dir + "/.", destination_path)
-          end
-        end
-      end
-      @repo_directory
-    end
-
-    def perform_relative_path_fetch(destination_path, working_dir)
-      Inspec::Log.debug("Checkout of #{resolved_ref} successful. " \
-                        "Moving #{@relative_path} to #{destination_path}")
-      unless File.exist?("#{working_dir}/#{@relative_path}")
-        # Cleanup the destination path - otherwise we'll have an empty dir
-        # in the cache, which is enough to confuse the cache reader
-        # This is a courtesy, assuming we're writing to the cache; if we're
-        # vendoring to something more complex, don't bother.
-        FileUtils.rmdir(destination_path) if Dir.empty?(destination_path)
-
-        raise Inspec::FetcherFailure, "Cannot find relative path '#{@relative_path}' " \
-                                      "within profile in git repo specified by '#{@remote_url}'"
-      end
-      FileUtils.cp_r("#{working_dir}/#{@relative_path}", destination_path)
-    end
-
-    def cache_key
-      return resolved_ref unless @relative_path
-
-      OpenSSL::Digest::SHA256.hexdigest(resolved_ref + @relative_path)
-    end
-
-    def archive_path
-      @repo_directory
-    end
-
-    def resolved_source
-      source = { git: @remote_url, ref: resolved_ref }
-      source[:relative_path] = @relative_path if @relative_path
-      source
-    end
-
-    private
-
-    def resolved_ref
-      @resolved_ref ||= if @ref
-                          @ref
-                        elsif @branch
-                          resolve_ref(@branch)
-                        elsif @tag
-                          resolve_ref(@tag)
-                        else
-                          resolve_ref("master")
-                        end
-    end
-
-    def resolve_ref(ref_name)
-      command_string = "git ls-remote \"#{@remote_url}\" \"#{ref_name}*\""
-      cmd = shellout(command_string)
-      raise(Inspec::FetcherFailure, "Profile git dependency failed for #{@remote_url} - error running '#{command_string}': #{cmd.stderr}") unless cmd.exitstatus == 0
-
-      ref = parse_ls_remote(cmd.stdout, ref_name)
-      unless ref
-        raise Inspec::FetcherFailure, "Profile git dependency failed - unable to resolve #{ref_name} to a specific git commit for #{@remote_url}"
-      end
-
-      ref
-    end
-
-    #
-    # The following comment is a minor modification of the comment in
-    # the omnibus source for a similar function:
-    #
-    # Dereference annotated tags.
-    #
-    # The +remote_list+ parameter is assumed to look like this:
-    #
-    #   a2ed66c01f42514bcab77fd628149eccb4ecee28        refs/tags/rel-0.11.0
-    #   f915286abdbc1907878376cce9222ac0b08b12b8        refs/tags/rel-0.11.0^{}
-    #
-    # The SHA with ^{} is the commit pointed to by an annotated
-    # tag. If ref isn't an annotated tag, there will not be a line
-    # with trailing ^{}.
-    #
-    # @param [String] output
-    #   output from `git ls-remote origin` command
-    # @param [String] ref_name
-    #   the target git ref_name
-    #
-    # @return [String]
-    #
-    def parse_ls_remote(output, ref_name)
-      pairs = output.lines.map { |l| l.chomp.split("\t") }
-      tagged_commit = pairs.find { |m| m[1].end_with?("#{ref_name}^{}") }
-      if tagged_commit
-        tagged_commit.first
-      else
-        pairs.find { |m| m[1].end_with?(ref_name.to_s) }&.first
-      end
-    end
-
-    def cloned?
-      File.directory?(File.join(@repo_directory, ".git"))
-    end
-
-    def clone(dir = @repo_directory)
-      git_cmd("clone #{@remote_url} ./", dir) unless cloned?
-      @repo_directory
-    end
-
-    def checkout(dir = @repo_directory)
-      clone(dir)
-      git_cmd("checkout #{resolved_ref}", dir)
-      @repo_directory
-    end
-
-    def git_cmd(cmd, dir = @repo_directory)
-      cmd = shellout("git #{cmd}", cwd: dir)
-      cmd.error!
-      cmd.status
-    rescue Errno::ENOENT
-      raise Inspec::FetcherFailure, "Profile git dependency failed for #{@remote_url} - to use git sources, you must have git installed."
-    end
-
-    def shellout(cmd, opts = {})
-      Inspec::Log.debug("Running external command: #{cmd} (#{opts})")
-      cmd = Mixlib::ShellOut.new(cmd, opts)
-      cmd.run_command
-      Inspec::Log.debug("External command: completed with exit status: #{cmd.exitstatus}")
-      Inspec::Log.debug("External command: STDOUT BEGIN")
-      Inspec::Log.debug(cmd.stdout)
-      Inspec::Log.debug("External command: STDOUT END")
-      Inspec::Log.debug("External command: STDERR BEGIN")
-      Inspec::Log.debug(cmd.stderr)
-      Inspec::Log.debug("External command: STDERR END")
-      cmd
-    end
-  end
-end

data/lib/inspec/fetcher/local.rb

@@ -1,116 +0,0 @@
-require "openssl"
-
-module Inspec::Fetcher
-  class Local < Inspec.fetcher(1)
-    name "local"
-    priority 0
-
-    def self.resolve(target)
-      if target.is_a?(String)
-        local_path = resolve_from_string(target)
-        new(local_path) if local_path
-      elsif target.is_a?(Hash)
-        local_path = resolve_from_hash(target)
-        new(local_path, target) if local_path
-      end
-    end
-
-    def self.resolve_from_hash(target)
-      return unless target.key?(:path)
-
-      if target.key?(:cwd)
-        File.expand_path(target[:path], target[:cwd])
-      else
-        target[:path]
-      end
-    end
-
-    def self.resolve_from_string(target)
-      # Support "urls" in the form of file://
-      if target.start_with?("file://")
-        target = target.gsub(%r{^file://}, "")
-      else
-        # support for windows paths
-        target = target.tr('\\', "/")
-      end
-
-      target if File.exist?(File.expand_path(target))
-    end
-
-    def initialize(target, opts = {})
-      @target = target
-      @backend = opts[:backend]
-      @archive_shasum = nil
-    end
-
-    def fetch(path)
-      # If `inspec exec` is used then we should not vendor/fetch. This makes
-      # local development easier and more predictable.
-      return @target if Inspec::BaseCLI.inspec_cli_command == :exec
-
-      # Skip vendoring if @backend is not set (example: ad hoc runners)
-      return @target unless @backend
-
-      if File.directory?(@target)
-        # Create an archive, checksum, and move to the vendor directory
-        Dir.mktmpdir do |tmpdir|
-          temp_archive = File.join(tmpdir, "#{File.basename(@target)}.tar.gz")
-          opts = {
-            backend: @backend,
-            output: temp_archive,
-          }
-
-          # Create a temporary archive at `opts[:output]`
-          Inspec::Profile.for_target(@target, opts).archive(opts)
-
-          checksum = perform_shasum(temp_archive)
-          final_path = File.join(path, checksum)
-          FileUtils.mkdir_p(final_path)
-          Inspec::FileProvider.for_path(temp_archive).extract(final_path)
-        end
-      else
-        # Verify profile (archive) is valid and extract to vendor directory
-        opts = { backend: @backend }
-        Inspec::Profile.for_target(@target, opts).check
-        Inspec::FileProvider.for_path(@target).extract(path)
-      end
-
-      @target
-    end
-
-    def archive_path
-      @target
-    end
-
-    def writable?
-      File.directory?(@target)
-    end
-
-    def cache_key
-      sha256.to_s
-    end
-
-    def sha256
-      if !@archive_shasum.nil?
-        @archive_shasum
-      elsif File.directory?(@target)
-        nil
-      else
-        perform_shasum(@target)
-      end
-    end
-
-    def perform_shasum(target)
-      return @archive_shasum if @archive_shasum
-      raise(Inspec::FetcherFailure, "Profile dependency local path '#{target}' does not exist") unless File.exist?(target)
-
-      @archive_shasum = OpenSSL::Digest::SHA256.digest(File.read(target)).unpack("H*")[0]
-    end
-
-    def resolved_source
-      h = { path: @target }
-      h[:sha256] = sha256 if sha256
-      h
-    end
-  end
-end