inspec-core 2.1.67

data/lib/inspec/completions/bash.sh.erb

@@ -0,0 +1,45 @@
+_inspec() {
+    local _inspec_top_level_commands="<%= top_level_commands.join(" ") %>"
+    <% subcommands_with_commands.each do |name, subcommands| -%>
+local _inspec_<%= name %>_commands="<%= subcommands.join(" ") -%>"
+    <% end -%>
+
+    cur=${COMP_WORDS[COMP_CWORD]}
+    prev=${COMP_WORDS[COMP_CWORD-1]}
+
+    if [ "$COMP_CWORD" -eq 1 ]; then
+        case "$prev" in
+            inspec)
+                COMPREPLY=( $( compgen -W "$_inspec_top_level_commands" -- "$cur" ) )
+                ;;
+        esac
+    elif [ "$COMP_CWORD" -eq 2 ]; then
+        case "$prev" in
+            archive|check|exec|json)
+                COMPREPLY=( $( compgen -f -- "$cur" ) )
+                ;;
+            help)
+                COMPREPLY=( $( compgen -W "$_inspec_top_level_commands" -- "$cur" ) )
+                ;;
+<% subcommands_with_commands.each do |name, subcommands| -%>
+           <%= name %>)
+                COMPREPLY=( $( compgen -W "$_inspec_<%= name %>_commands" -- "$cur" ) )
+                ;;
+<% end -%>
+        esac
+    elif [ "$COMP_CWORD" -eq 3 ]; then
+        prev2=${COMP_WORDS[COMP_CWORD-2]}
+        case "$prev2-$prev" in
+            compliance-upload)
+                COMPREPLY=( $( compgen -f -- "$cur" ) )
+                ;;
+<% subcommands_with_commands.each do |name, subcommands| -%>
+           <%= name %>-help)
+                COMPREPLY=( $( compgen -W "$_inspec_<%= name %>_commands" -- "$cur" ) )
+                ;;
+<% end -%>
+        esac
+    fi
+}
+
+complete -F _inspec inspec

data/lib/inspec/completions/fish.sh.erb

@@ -0,0 +1,34 @@
+function __fish_inspec_no_command --description 'Test if inspec has yet to be given the main command'
+  set -l cmd (commandline -opc)
+  test (count $cmd) -eq 1
+end
+
+function __fish_inspec_using_command
+  set -l cmd (commandline -opc)
+  set -q cmd[2]; and test "$argv[1]" = $cmd[2]
+end
+
+function __fish_inspec_using_command_and_no_subcommand
+  set -l cmd (commandline -opc)
+  test (count $cmd) -eq 2; and test "$argv[1]" = "$cmd[2]"
+end
+
+function __fish_inspec_using_subcommand --argument-names cmd_main cmd_sub
+    set -l cmd (commandline -opc)
+    set -q cmd[3]; and test "$cmd_main" = $cmd[2] -a "$cmd_sub" = $cmd[3]
+end
+
+<% top_level_commands_with_descriptions.each do |command_and_description| %>
+  <% command, description = command_and_description.split(':') %>
+  <% description.gsub!(/\\/, '') %>
+  # <%= command %> commands
+  complete -c inspec -f -n '__fish_inspec_no_command' -a <%= command %> -d "<%= description %>"
+  # <%= command %> help
+  complete -c inspec -f -n '__fish_inspec_using_command help' -a <%= command %> -d "<%= description %>"
+
+  <% (subcommands_with_commands_and_descriptions[command] || []).each do |command_and_description| %>
+    <% subcommand, description = command_and_description.split(':') %>
+    <% description.gsub!(/\\/, '') %>
+    complete -c inspec -f -n '__fish_inspec_using_command_and_no_subcommand <%= command %>' -a <%= subcommand %> -d "<%= description %>"
+  <% end %>
+<% end %>

data/lib/inspec/completions/zsh.sh.erb

@@ -0,0 +1,61 @@
+function _inspec() {
+    local curcontext="$curcontext" state line
+    typeset -A opt_args
+
+    local -a _top_level_commands <%= subcommands_with_commands_and_descriptions.keys.map {|i| "_#{i}_commands" }.join(' ') %>
+
+    _top_level_commands=(
+<%= top_level_commands_with_descriptions.map {|i| " "*8 + "\"#{i}\"" }. join("\n") %>
+    )
+
+<% subcommands_with_commands_and_descriptions.each do |name, entry| -%>
+    _<%= name %>_commands=(
+<%= entry.map {|i| " "*8 + "\"#{i}\"" }.join("\n") %>
+    )
+
+<% end -%>
+    _arguments '1:::->toplevel' && return 0
+    _arguments '2:::->subcommand' && return 0
+    _arguments '3:::->subsubcommand' && return 0
+
+    #
+    # Are you thinking? "Jeez, whoever wrote this really doesn't get
+    # zsh's completion system?" If so, you are correct. However, I
+    # have goodnews! Pull requests are accepted!
+    #
+    case $state in
+        toplevel)
+            _describe -t commands "InSpec subcommands" _top_level_commands
+            ;;
+        subcommand)
+            case "$words[2]" in
+                archive|check|exec|json)
+                    _alternative 'files:filenames:_files'
+                    ;;
+                help)
+                    _describe -t commands "InSpec subcommands" _top_level_commands
+                    ;;
+<% subcommands_with_commands_and_descriptions.each do |name, entry| -%>
+                <%= name %>)
+                    _describe -t <%= name %>_commands "InSpec <%= name -%> subcommands" _<%= name %>_commands
+                    ;;
+<% end -%>
+            esac
+            ;;
+        subsubcommand)
+            case "$words[2]-$words[3]" in
+                compliance-upload)
+                    _alternative 'files:filenames:_files'
+                    ;;
+<% subcommands_with_commands_and_descriptions.each do |name, entry| -%>
+                <%= name %>-help)
+                    _describe -t <%= name %>_commands "InSpec <%= name %> subcommands" _<%= name %>_commands
+                    ;;
+<% end -%>
+            esac
+
+    esac
+
+}
+
+compdef _inspec inspec

data/lib/inspec/control_eval_context.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+require 'inspec/dsl'
+require 'inspec/dsl_shared'
+
+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)
+      require 'rspec/core/dsl'
+      Class.new(Inspec::Rule) do
+        include RSpec::Core::DSL
+        with_resource_dsl resources_dsl
+      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
+      rule_class = rule_context(resources_dsl)
+      profile_context_owner = profile_context
+      profile_id = profile_context.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 = 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)
+          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, 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, msg)
+          end
+
+          profile_context_owner.register_rule(control, &block) unless control.nil?
+        end
+
+        # method for attributes; import attribute handling
+        define_method :attribute do |name, options|
+          profile_context_owner.register_attribute(name, options)
+        end
+
+        define_method :skip_control do |id|
+          profile_context_owner.unregister_rule(id)
+        end
+
+        define_method :only_if do |&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) if sources_match
+          end
+
+          @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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+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(Dir.home, '.inspec', 'cache')
+      FileUtils.mkdir_p(@path) unless File.directory?(@path)
+    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

@@ -0,0 +1,92 @@
+# encoding: utf-8
+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, cwd, cache, backend, opts = {})
+      dep_tree = lockfile.deps.map do |dep|
+        Inspec::Requirement.from_lock_entry(dep, cwd, cache, backend, opts)
+      end
+
+      dep_list = flatten_dep_tree(dep_tree)
+      new(cwd, cache, dep_list, 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_writer :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