inspec-core 2.1.67

data/lib/inspec/env_printer.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+require 'inspec/shell_detector'
+require 'erb'
+require 'shellwords'
+
+module Inspec
+  class EnvPrinter
+    attr_reader :shell
+
+    EVAL_COMMANDS = {
+      'bash' => 'eval \"$(inspec env bash)\"',
+      'fish' => 'inspec env fish > ~/.config/fish/completions/inspec.fish',
+      'zsh' => 'eval \"$(inspec env zsh)\"',
+    }.freeze
+
+    def initialize(command_class, shell = nil)
+      if !shell
+        @detected = true
+        @shell = Inspec::ShellDetector.new.shell
+      else
+        @shell = shell
+      end
+      @command_class = command_class
+    end
+
+    def print_and_exit!
+      exit_no_shell if !have_shell?
+      exit_no_completion if !have_shell_completion?
+
+      print_completion_for_shell
+      print_detection_warning($stdout) if @detected
+      print_usage_guidance
+      exit 0
+    end
+
+    private
+
+    def print_completion_for_shell
+      erb = ERB.new(File.read(completion_template_path), nil, '-')
+      puts erb.result(TemplateContext.new(@command_class).get_bindings)
+    end
+
+    def have_shell?
+      !(@shell.nil? || @shell.empty?)
+    end
+
+    def have_shell_completion?
+      File.exist?(completion_template_path)
+    end
+
+    def completion_dir
+      File.join(File.dirname(__FILE__), 'completions')
+    end
+
+    def completion_template_path
+      File.join(completion_dir, "#{@shell}.sh.erb")
+    end
+
+    def shells_with_completions
+      Dir.glob("#{completion_dir}/*.sh.erb").map { |f| File.basename(f, '.sh.erb') }
+    end
+
+    def print_usage_guidance
+      puts <<~EOF
+        # To use this, eval it in your shell
+        #
+        #    #{EVAL_COMMANDS[shell]}
+        #
+        #
+      EOF
+    end
+
+    def print_detection_warning(device)
+      device.puts <<~EOF
+        #
+        # The shell #{@shell} was auto-detected. If this is incorrect, please
+        # specify a shell explicitly by running:
+        #
+        #     inspec env SHELLNAME
+        #
+        # Currently supported shells are: #{shells_with_completions.join(', ')}
+        #
+      EOF
+    end
+
+    def exit_no_completion
+      $stderr.puts "# No completion script for #{@shell}!"
+      print_detection_warning($stderr) if @detected
+      exit 1
+    end
+
+    def exit_no_shell
+      if @detected
+        $stderr.puts '# Unable to automatically detect shell and no shell was provided.'
+      end
+      $stderr.puts <<~EOF
+        #
+        # Please provide the name of your shell via the command line:
+        #
+        #    inspec env SHELLNAME
+        #
+        # Currently supported shells are: #{shells_with_completions.join(', ')}
+      EOF
+      exit 1
+    end
+
+    class TemplateContext
+      def initialize(command_class)
+        @command_class = command_class
+      end
+
+      def get_bindings # rubocop:disable Style/AccessorMethodName
+        binding
+      end
+
+      #
+      # The following functions all assume that @command_class
+      # is something that provides a Thor-like API
+      #
+      def top_level_commands
+        commands_for_thor_class(@command_class)
+      end
+
+      def top_level_commands_with_descriptions
+        descript_lines_for_class(@command_class)
+      end
+
+      def subcommands_with_commands
+        ret = {}
+        @command_class.subcommand_classes.each do |k, v|
+          ret[k] = commands_for_thor_class(v)
+        end
+        ret
+      end
+
+      def subcommands_with_commands_and_descriptions
+        ret = {}
+        @command_class.subcommand_classes.each do |k, v|
+          ret[k] = descript_lines_for_class(v)
+        end
+        ret
+      end
+
+      def commands_for_thor_class(thor_class)
+        thor_class.all_commands.values.map { |c| c.usage.split.first }
+      end
+
+      def descript_lines_for_class(thor_class)
+        thor_class.all_commands.values.map { |c| descript_line_for_command(c) }
+      end
+
+      def descript_line_for_command(c)
+        "#{c.usage.split.first}:#{Shellwords.escape(c.description)}"
+      end
+    end
+  end
+end

data/lib/inspec/errors.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+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
+end

data/lib/inspec/exceptions.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# copyright: 2017, Chef Software Inc.
+
+module Inspec
+  module Exceptions
+    class AttributesFileDoesNotExist < ArgumentError; end
+    class AttributesFileNotReadable < ArgumentError; end
+    class ResourceFailed < StandardError; end
+    class ResourceSkipped < StandardError; end
+    class SecretsBackendNotFound < ArgumentError; end
+  end
+end

data/lib/inspec/expect.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# copyright: 2016, Chef Software Inc.
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+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] }
+      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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'inspec/plugins'
+require 'utils/plugin_registry'
+
+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 = [: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 if !target.respond_to?(:keys)
+      !(target.keys - NON_FETCHER_KEYS).empty?
+    end
+
+    def with_default_fetcher(target)
+      target.merge({ supermarket: target[:name] })
+    end
+  end
+
+  Fetcher = FetcherRegistry.new
+
+  def self.fetcher(version)
+    if version != 1
+      raise 'Only fetcher version 1 is supported!'
+    end
+    Inspec::Plugins::Fetcher
+  end
+end
+
+require 'fetchers/local'
+require 'fetchers/url'
+require 'fetchers/git'

data/lib/inspec/file_provider.rb

@@ -0,0 +1,275 @@
+# encoding: utf-8
+require 'rubygems/package'
+require 'zlib'
+require 'zip'
+
+module Inspec
+  class FileProvider
+    def self.for_path(path)
+      if path.is_a?(Hash)
+        MockProvider.new(path)
+      elsif File.directory?(path)
+        DirProvider.new(path)
+      elsif File.exist?(path) && path.end_with?('.tar.gz', 'tgz')
+        TarProvider.new(path)
+      elsif File.exist?(path) && path.end_with?('.zip')
+        ZipProvider.new(path)
+      elsif File.exist?(path)
+        DirProvider.new(path)
+      else
+        raise "No file provider for the provided path: #{path}"
+      end
+    end
+
+    def initialize(_path)
+    end
+
+    # List all files that are offered.
+    #
+    # @return [Array[String]] list of file paths that are included
+    def files
+      raise "Fetcher #{self} does not implement `files()`. This is required."
+    end
+
+    # Read the contents of a file. This will typically refer to a text
+    # file reading a string.
+    #
+    # @param _file [String] path of the file to be read
+    # @return [String] contents of the file described
+    def read(_file)
+      raise "#{self} does not implement `read(...)`. This is required."
+    end
+
+    # Provide a method for reading binary contents from a file.
+    # It will default to #read if not defined. For most streams that implement
+    # it, it will be the same. For some special cases, it will add change the
+    # way in which encoding of the returned data structure is handled.
+    # Does not work with alias nor alias_method.
+    def binread(file)
+      read(file)
+    end
+
+    def relative_provider
+      RelativeFileProvider.new(self)
+    end
+  end
+
+  class MockProvider < FileProvider
+    attr_reader :files
+    def initialize(path)
+      @data = path[:mock]
+      @files = @data.keys
+    end
+
+    def read(file)
+      @data[file]
+    end
+  end
+
+  class DirProvider < FileProvider
+    attr_reader :files
+    def initialize(path)
+      @files = if File.file?(path)
+                 [path]
+               else
+                 Dir[File.join(Shellwords.shellescape(path), '**', '*')]
+               end
+      @path = path
+    end
+
+    def read(file)
+      return nil unless files.include?(file)
+      return nil unless File.file?(file)
+      File.read(file)
+    end
+
+    def binread(file)
+      return nil unless files.include?(file)
+      return nil unless File.file?(file)
+      File.binread(file)
+    end
+  end
+
+  class ZipProvider < FileProvider
+    attr_reader :files
+
+    def initialize(path)
+      @path = path
+      @contents = {}
+      @files = []
+      walk_zip(@path) do |io|
+        while (entry = io.get_next_entry)
+          name = entry.name.sub(%r{/+$}, '')
+          @files.push(name) unless name.empty?
+        end
+      end
+    end
+
+    def read(file)
+      @contents[file] ||= read_from_zip(file)
+    end
+
+    private
+
+    def walk_zip(path, &callback)
+      ::Zip::InputStream.open(path, &callback)
+    end
+
+    def read_from_zip(file)
+      return nil unless @files.include?(file)
+      res = nil
+      walk_zip(@path) do |io|
+        while (entry = io.get_next_entry)
+          next unless file == entry.name
+          res = io.read
+          break
+        end
+      end
+      res
+    end
+  end
+
+  class TarProvider < FileProvider
+    attr_reader :files
+
+    def initialize(path)
+      @path = path
+      @contents = {}
+      @files = []
+      walk_tar(@path) do |tar|
+        @files = tar.find_all(&:file?)
+
+        # delete all entries with no name
+        @files = @files.find_all { |x| !x.full_name.empty? }
+
+        # delete all entries that have a PaxHeader
+        @files = @files.delete_if { |x| x.full_name.include?('PaxHeader/') }
+
+        # replace all items of the array simply with the relative filename of the file
+        @files.map! { |x| Pathname.new(x.full_name).relative_path_from(Pathname.new('.')).to_s }
+      end
+    end
+
+    def read(file)
+      @contents[file] ||= read_from_tar(file)
+    end
+
+    private
+
+    def walk_tar(path, &callback)
+      Gem::Package::TarReader.new(Zlib::GzipReader.open(path), &callback)
+    end
+
+    def read_from_tar(file)
+      return nil unless @files.include?(file)
+      res = nil
+      # NB `TarReader` includes `Enumerable` beginning with Ruby 2.x
+      walk_tar(@path) do |tar|
+        tar.each do |entry|
+          next unless entry.file? && [file, "./#{file}"].include?(entry.full_name)
+          res = entry.read
+          break
+        end
+      end
+      res
+    end
+  end
+
+  class RelativeFileProvider
+    BLACKLIST_FILES = [
+      '/pax_global_header',
+      'pax_global_header',
+    ].freeze
+
+    attr_reader :files
+    attr_reader :prefix
+    attr_reader :parent
+
+    def initialize(parent_provider)
+      @parent = parent_provider
+      @prefix = get_prefix(parent.files)
+      if @prefix.nil?
+        raise "Could not determine path prefix for #{parent}"
+      end
+
+      # select all files that begin with the prefix, and strip off the prefix from the file.
+      #
+      # strip off any leading top-level relative path (./) which is common in
+      # PAX-formatted tar files. Do not do any translation of the path if the
+      # path is an absolute path.
+      @files = parent.files
+                     .find_all { |x| x.start_with?(prefix) && x != prefix }
+                     .map { |x| x[prefix.length..-1] }
+                     .map do |x|
+                       path = Pathname.new(x)
+                       path.absolute? ? path.to_s : path.relative_path_from(Pathname.new('.')).to_s
+                     end
+    end
+
+    def abs_path(file)
+      return nil if file.nil?
+      prefix + file
+    end
+
+    def read(file)
+      parent.read(abs_path(file))
+    end
+
+    def binread(file)
+      parent.binread(abs_path(file))
+    end
+
+    private
+
+    def get_prefix(fs)
+      return '' if fs.empty?
+
+      # filter backlisted files
+      fs -= BLACKLIST_FILES
+
+      sorted = fs.sort_by(&:length)
+      get_folder_prefix(sorted)
+    end
+
+    def prefix_candidate_for(file)
+      if file.end_with?(File::SEPARATOR)
+        file
+      else
+        file + File::SEPARATOR
+      end
+    end
+
+    def get_folder_prefix(fs)
+      return get_files_prefix(fs) if fs.length == 1
+      first, *rest = fs
+      pre = prefix_candidate_for(first)
+
+      if rest.all? { |i| i.start_with? pre }
+        return get_folder_prefix(rest)
+      end
+      get_files_prefix(fs)
+    end
+
+    def get_files_prefix(fs)
+      return '' if fs.empty?
+
+      file = fs[0]
+      bn = File.basename(file)
+      # no more prefixes
+      return '' if bn == file
+
+      i = file.rindex(bn)
+      pre = file[0..i-1]
+
+      rest = fs.find_all { |f| !f.start_with?(pre) }
+      return pre if rest.empty?
+
+      new_pre = get_prefix(rest)
+      return new_pre if pre.start_with? new_pre
+      # edge case: completely different prefixes; retry prefix detection
+      a = File.dirname(pre + 'a')
+      b = File.dirname(new_pre + 'b')
+      get_prefix([a, b])
+    end
+  end
+end