inspec 4.18.51 → 4.18.85

data/lib/inspec/ui_table_helper.rb

@@ -1,12 +0,0 @@
-require "tty-table"
-
-module Inspec
-  class UI
-    class TableHelper < TTY::Table
-      def header=(ary)
-        cells = ary.dup.map { |label| { value: label, alignment: :center } }
-        @header = TTY::Table::Header.new(cells)
-      end
-    end
-  end
-end

data/lib/inspec/utils/command_wrapper.rb

@@ -1,23 +0,0 @@
-require "shellwords"
-
-class CommandWrapper
-  UNIX_SHELLS = %w{sh bash zsh ksh}.freeze
-
-  def self.wrap(cmd, options)
-    unless options.is_a?(Hash)
-      raise "All options for the command wrapper must be provided as a hash. "\
-        "You entered: #{options.inspect}. Please consult the documentation."
-    end
-
-    wrap = options[:wrap]
-    raise "Called command wrapper with wrap: #{wrap.inspect}. It must be called with a Proc." if !wrap.nil? && !wrap.is_a?(Proc)
-    return wrap.call(cmd) unless wrap.nil?
-
-    shell = options[:shell]
-    raise "Don't know how to wrap commands for shell: #{shell.inspect}." unless UNIX_SHELLS.include?(shell)
-
-    path = options[:path] || shell
-    args = options[:args] || "-c"
-    path.to_s + " " + args + " " + Shellwords.escape(cmd)
-  end
-end

data/lib/inspec/utils/convert.rb

@@ -1,8 +0,0 @@
-module Converter
-  # convert the value to an integer if we have numbers only
-  # otherwise we return the string
-  def convert_to_i(val)
-    val = val.to_i if val =~ /^\d+$/
-    val
-  end
-end

data/lib/inspec/utils/database_helpers.rb

@@ -1,75 +0,0 @@
-module DatabaseHelper
-  class SQLColumn
-    def initialize(row, name)
-      @row = row
-      @name = name
-    end
-
-    def value
-      @row.nil? ? "" : @row[@name.downcase]
-    end
-
-    def to_s
-      "SQL Column"
-    end
-  end
-
-  class SQLRow
-    def initialize(query, row)
-      @query = query
-      @row = row
-    end
-
-    def column(column)
-      SQLColumn.new(@row, column)
-    end
-
-    def to_s
-      "SQL Row"
-    end
-  end
-
-  class SQLQueryResult
-    attr_reader :error
-    def initialize(cmd, results)
-      @cmd = cmd
-      @results = results
-    end
-
-    def empty?
-      @results.empty?
-    end
-
-    def successful?
-      @cmd.exit_status == 0 && @error.nil?
-    end
-
-    def rows
-      @results
-    end
-
-    def row(id)
-      SQLRow.new(self, @results[id])
-    end
-
-    def column(column)
-      result = []
-      @results.each do |row|
-        result << row[column]
-      end
-      result
-    end
-
-    def size
-      @results.size
-    end
-
-    def inspect
-      to_s
-    end
-
-    def to_s
-      "SQL ResultSet"
-    end
-  end
-end

data/lib/inspec/utils/deprecation.rb

@@ -1,6 +0,0 @@
-# A system to provide a unified deprecation facility for InSpec
-
-require "inspec/utils/deprecation/errors"
-require "inspec/utils/deprecation/config_file"
-require "inspec/utils/deprecation/deprecator"
-require "inspec/utils/deprecation/global_method"

data/lib/inspec/utils/deprecation/config_file.rb

@@ -1,109 +0,0 @@
-require "stringio"
-require "json"
-require "inspec/globals"
-
-module Inspec
-  module Deprecation
-    class ConfigFile
-      GroupEntry = Struct.new(:name, :action, :prefix, :suffix, :exit_status)
-
-      # What actions may you specify to be taken when a deprecation is encountered?
-      VALID_ACTIONS = [
-        :exit, # Hard exit `inspec`, no stacktrace, exit code specified or Inspec::UI::EXIT_FATAL_DEPRECATION
-        :fail_control, # Fail the control with a message. If not in a control, do :warn action instead.
-        :ignore, # Do nothing.
-        :warn, # Issue a warning
-      ].freeze
-
-      # Note that 'comment' is ignored, but listed here so you can have it present
-      # and pass validation.
-      VALID_GROUP_FIELDS = %w{action suffix prefix exit_status comment}.freeze
-
-      attr_reader :groups, :unknown_group_action
-
-      def initialize(io = nil)
-        io ||= open_default_config_io
-        begin
-          @raw_data = JSON.parse(io.read)
-        rescue JSON::ParserError => e
-          raise Inspec::Deprecation::MalformedConfigFileError, "Could not parse deprecation config file: #{e.message}"
-        end
-
-        @groups = {}
-        @unknown_group_action = :warn
-        validate!
-      end
-
-      private
-
-      def open_default_config_io
-        default_path = File.join(Inspec.src_root, "etc", "deprecations.json")
-        unless File.exist?(default_path)
-          raise Inspec::Deprecation::MalformedConfigError, "Missing deprecation config file: #{default_path}"
-        end
-
-        File.open(default_path)
-      end
-
-      #====================================================================================================#
-      #                                          Validation
-      #====================================================================================================#
-      def validate!
-        validate_file_version
-        validate_unknown_group_action
-
-        unless @raw_data.key?("groups")
-          raise Inspec::Deprecation::InvalidConfigFileError, "Missing groups field"
-        end
-        unless @raw_data["groups"].is_a?(Hash)
-          raise Inspec::Deprecation::InvalidConfigFileError, "Groups field must be a Hash"
-        end
-
-        @raw_data["groups"].each do |group_name, group_info|
-          validate_group_entry(group_name, group_info)
-        end
-      end
-
-      def validate_file_version
-        unless @raw_data.key?("file_version")
-          raise Inspec::Deprecation::InvalidConfigFileError, "Missing file_version field"
-        end
-        unless @raw_data["file_version"] == "1.0.0"
-          raise Inspec::Deprecation::InvalidConfigFileError, "Unrecognized file_version '#{@raw_data["file_version"]}' - supported versions: 1.0.0"
-        end
-      end
-
-      def validate_unknown_group_action
-        seen_action = (@raw_data["unknown_group_action"] || @unknown_group_action).to_sym
-        unless VALID_ACTIONS.include?(seen_action)
-          raise Inspec::Deprecation::UnrecognizedActionError, "Unrecognized value '#{seen_action}' for field 'unknown_group_action' - supported actions: #{VALID_ACTIONS.map(&:to_s).join(", ")}"
-        end
-
-        @unknown_group_action = seen_action
-      end
-
-      def validate_group_entry(name, opts)
-        opts.each do |seen_field, _value|
-          unless VALID_GROUP_FIELDS.include?(seen_field)
-            raise Inspec::Deprecation::InvalidConfigFileError, "Unrecognized field for group '#{name}' - saw '#{seen_field}', supported fields: #{VALID_GROUP_FIELDS.map(&:to_s).join(", ")}"
-          end
-        end
-
-        entry = GroupEntry.new(name.to_sym)
-
-        opts["action"] = (opts["action"] || :warn).to_sym
-        unless VALID_ACTIONS.include?(opts["action"])
-          raise Inspec::Deprecation::UnrecognizedActionError, "Unrecognized action for group '#{name}' - saw '#{opts["action"]}', supported actions: #{VALID_ACTIONS.map(&:to_s).join(", ")}"
-        end
-
-        entry.action = opts["action"]
-
-        entry.suffix = opts["suffix"]
-        entry.prefix = opts["prefix"]
-        entry.exit_status = opts["exit_status"]
-
-        groups[name.to_sym] = entry
-      end
-    end
-  end
-end

data/lib/inspec/utils/deprecation/deprecator.rb

@@ -1,118 +0,0 @@
-require "inspec/utils/deprecation/config_file"
-require "inspec/log"
-
-module Inspec
-  module Deprecation
-    class Deprecator
-      attr_reader :config, :groups
-
-      def initialize(opts = {})
-        @config = Inspec::Deprecation::ConfigFile.new(opts[:config_io])
-        @groups = @config.groups
-      end
-
-      def handle_deprecation(group_name, message, opts = {})
-        group = groups[group_name.to_sym] || create_group_entry_for_unknown_group(group_name)
-        annotate_stack_information(opts)
-        assembled_message = assemble_message(message, group, opts)
-
-        action = group[:action] || :warn
-        action_method = ("handle_" + action.to_s + "_action").to_sym
-        send(action_method, group_name.to_sym, assembled_message, group)
-      end
-
-      private
-
-      def create_group_entry_for_unknown_group(group_name)
-        group = ConfigFile::GroupEntry.new
-        group.name = group_name
-        group.action = config.unknown_group_action
-        group.suffix = "Additionally, the deprecation message is in an unknown group '#{group_name}'."
-        group
-      end
-
-      def annotate_stack_information(opts)
-        stack = caller_locations(1, 25)
-
-        # Attempt to give a meaningful stack location of the place
-        # where the deprecated functionality was used.  This is likely
-        # user (profile) code.
-        used_at = nil
-
-        # If we are in a profile, call stack will first include RSpec its,
-        # then a single call from the profile that originated within a load_with_context.
-        # rspec-core surrounds these.
-
-        # First, purge the deprecation system frames
-        stack.reject! { |frame| frame.path && frame.path =~ %r{lib/inspec/utils/deprecation} }
-        # Next, purge all RSpec entries (at least rspec-core, rspec-support, rspec-its).
-        stack.reject! { |frame| frame.path && frame.path =~ %r{rspec-.+/lib/rspec}  }
-        # Now look for the frame that includes load_with_context.
-        used_at ||= stack.detect { |frame| frame.label.include? "load_with_context" }
-
-        opts[:used_at_stack_frame] = used_at if used_at
-      end
-
-      def assemble_message(message, group, opts)
-        prefix = group.prefix || ""
-        suffix = group.suffix || ""
-        prefix += " " unless prefix.empty?
-        suffix = " " + suffix unless suffix.empty?
-
-        suffix += (" (used at " + opts[:used_at_stack_frame].path + ":" + opts[:used_at_stack_frame].lineno.to_s + ")") if opts.key?(:used_at_stack_frame)
-
-        "DEPRECATION: " + prefix + message + suffix
-      end
-
-      def called_from_control?
-        # Heuristics for determining if the deprecation is coming from within a control
-        stack = caller_locations(10, 45)
-
-        # Within a control block, that is actually an RSpec:ExampleGroup
-        stack.each do |frame|
-          return true if frame.path.end_with?("rspec/core/example_group.rb")
-        end
-
-        false
-      end
-
-      # Unused args needed for unit test deprecation harness
-      def handle_ignore_action(_group_name, message, _group)
-        handle_log_action(message, :debug)
-      end
-
-      def handle_log_action(message, level)
-        case level
-        when :debug
-          Inspec::Log.debug message
-        when :warn
-          Inspec::Log.warn message
-        when :error
-          Inspec::Log.error message
-        end
-      end
-
-      def handle_warn_action(_group_name, message, _group)
-        handle_log_action(message, :warn)
-      end
-
-      def handle_error_action(_group_name, message, _group)
-        handle_log_action(message, :error)
-      end
-
-      def handle_fail_control_action(group_name, message, group)
-        if called_from_control?
-          raise Inspec::Exceptions::ResourceFailed, message
-        else
-          handle_warn_action(group_name, message, group)
-        end
-      end
-
-      def handle_exit_action(group_name, message, group)
-        handle_error_action(group_name, message, group)
-        status = group[:exit_status] || :fatal_deprecation
-        Inspec::UI.new.exit(status)
-      end
-    end
-  end
-end

data/lib/inspec/utils/deprecation/errors.rb

@@ -1,14 +0,0 @@
-require "inspec/errors"
-
-module Inspec
-  module Deprecation
-    class Error < Inspec::Error; end
-
-    class NoSuchGroupError < Error; end
-
-    class InvalidConfigFileError < Error; end
-    class MalformedConfigFileError < InvalidConfigFileError; end
-    class UnrecognizedActionError < InvalidConfigFileError; end
-    class UnrecognizedOutputStreamError < InvalidConfigFileError; end
-  end
-end

data/lib/inspec/utils/deprecation/global_method.rb

@@ -1,9 +0,0 @@
-require "inspec/utils/deprecation/deprecator"
-
-module Inspec
-  def self.deprecate(group, msg = "", opts = {})
-    config_io = opts.delete(:config_io)
-    deprecator = Inspec::Deprecation::Deprecator.new(config_io: config_io)
-    deprecator.handle_deprecation(group, msg, opts)
-  end
-end

data/lib/inspec/utils/enumerable_delegation.rb

@@ -1,7 +0,0 @@
-module EnumerableDelegation
-  include Enumerable
-
-  def each(&block)
-    @params.each(&block)
-  end
-end

data/lib/inspec/utils/erlang_parser.rb

@@ -1,190 +0,0 @@
-require "parslet"
-
-class ErlangParser < Parslet::Parser
-  root :outermost
-  # only designed for rabbitmq config files for now:
-  rule(:outermost) { filler? >> array.maybe >> dot.maybe }
-
-  rule(:exp) do
-    (tuple | array | binary | string | bool | identifier | float | integer) >> filler?
-  end
-
-  rule(:array) do
-    str("[") >> filler? >> (
-      exp.repeat(1) >>
-      (comma >> exp).repeat
-    ).maybe.as(:array) >> str("]") >> filler?
-  end
-
-  rule(:tuple) do
-    str("{") >> filler? >> (
-      exp.repeat(1) >> filler? >>
-      (comma >> exp).repeat
-    ).maybe.as(:tuple) >> str("}") >> filler?
-  end
-
-  rule(:filler?) { space.repeat }
-  rule(:space)   { match('\s+') | match["\n"] | comment }
-
-  rule(:comment) { str("%") >> (match["\n\r"].absent? >> any).repeat }
-  rule(:comma) { str(",") >> filler? }
-  rule(:dot) { str(".") >> filler? }
-  rule(:bool) { str("true").as(:bool) | str("false").as(:bool) }
-
-  rule(:identifier) do
-    (match("[a-zA-Z]") >> match("[a-zA-Z0-9_]").repeat).as(:identifier) >> filler?
-  end
-
-  rule(:float) do
-    (
-      integer >> (
-        str(".") >> match("[0-9]").repeat(1) |
-        str("e") >> match("[0-9]").repeat(1)
-      ).as(:e)
-    ).as(:float) >> filler?
-  end
-
-  rule(:integer) do
-    ((str("+") | str("-")).maybe >> match("[0-9]").repeat(1)).as(:integer) >> filler?
-  end
-
-  rule(:string) { stringS | stringD }
-
-  rule(:stringS) do
-    str("'") >> (
-      str('\\') >> any | str("'").absent? >> any
-    ).repeat.as(:string) >> str("'") >> filler?
-  end
-
-  rule(:stringD) do
-    str('"') >> (
-      str('\\') >> any | str('"').absent? >> any
-    ).repeat.as(:string) >> str('"') >> filler?
-  end
-
-  rule(:binary_item) do
-    (string | integer) >>
-      (str(":") >> integer).maybe.as(:size) >>
-      (str("/") >> identifier).maybe.as(:type) >>
-      filler?
-  end
-
-  rule(:binary) do
-    str("<<") >> filler? >> (
-      binary_item.repeat(1) >>
-      (comma >> binary_item).repeat
-    ).maybe.as(:binary) >> str(">>") >> filler?
-  end
-end
-
-class ErlangBitstream
-  def initialize
-    @data = []     # a stream of 8-bit numbers
-    @cur_bits = "" # a string of binary bits 10010010...
-  end
-
-  TYPES = {
-    "integer" => 8,
-    "float" => 8 * 8,
-    "utf8" => 8,
-    "utf16" => 8 * 2,
-    "utf32" => 8 * 4,
-  }.freeze
-
-  def bit_size(size, type)
-    raise "Cannot specify size and type at the same time." if !type.nil? && !size.nil?
-    return (size || 8).to_i if type.nil?
-
-    TYPES[type] || raise("Cannot handle binary-stream type #{type}")
-  end
-
-  def add(i)
-    if i[:integer].nil? && i[:string].nil?
-      raise "No data provided, internal error for binary-stream processing!"
-    end
-
-    s = bit_size(i[:size], i[:type])
-    unless i[:string].nil?
-      str2int(i[:string].to_s, i[:type]).map { |e| add_bits(int2bits(e, 8)) }
-    else
-      add_int(i[:integer], s)
-    end
-  rescue RuntimeError => e
-    raise "Error processing Erlang bit string "\
-          "'#{i[:string] || i[:integer]}:#{i[:size]}/#{i[:type]}'. #{e.message}"
-  end
-
-  def str2int(s, type)
-    case type
-    when "utf8" then s.encode("utf-8").unpack("C*")
-    when "utf16" then s.encode("utf-16").unpack("C*").drop(2)
-    when "utf32" then s.encode("utf-32").unpack("C*").drop(4)
-    when "integer", "float" then raise "Cannot handle bit string as type #{type}"
-    else s.split("").map { |x| x.ord & 0xff }
-    end
-  end
-
-  def int2bits(i, len)
-    format("%0#{len}b", i)
-  end
-
-  def add_int(v, size)
-    x = v.to_i & (2**size - 1) # only get the bits specified in size
-    add_bits(int2bits(x, size))
-  end
-
-  def add_bits(s)
-    b = (@cur_bits + s).scan(/.{1,8}/)
-    @data += b[0..-2].map { |x| x.to_i(2) }
-    @cur_bits = b.last
-  end
-
-  def value(encoding = "utf-8")
-    # fill in the rest
-    rest = "0" * (8 - @cur_bits.length) + @cur_bits
-    arr = @data + [rest.to_i(2)]
-    s = arr.pack("C*")
-    s.force_encoding(encoding) unless encoding.nil?
-    s
-  end
-end
-
-class ErlangTransform < Parslet::Transform
-  class Tuple < Array; end
-  class Identifier < String; end
-
-  def self.assemble_binary(seq)
-    b = ErlangBitstream.new
-    seq.each { |i| b.add(i) }
-    b.value
-  end
-
-  rule(string: simple(:x)) { x.to_s }
-  rule(string: []) { "" }
-  rule(integer: simple(:x)) { x.to_i }
-  rule(float: { integer: simple(:a), e: simple(:b) }) { (a + b).to_f }
-  rule(bool: "true") { true }
-  rule(bool: "false") { false }
-  rule(binary: subtree(:x)) { x.nil? ? "" : ErlangTransform.assemble_binary(x) }
-  rule(identifier: simple(:x)) { Identifier.new(x.to_s) }
-  rule(array: subtree(:x)) { Array(x) }
-  rule(tuple: subtree(:x)) do
-    x.nil? ? Tuple.new : Tuple.new(x)
-  end
-end
-
-class ErlangConfigFile
-  def self.parse(content)
-    lex = ErlangParser.new.parse(content)
-    tree = ErlangTransform.new.apply(lex)
-    turn_to_hash(tree)
-  end
-
-  def self.turn_to_hash(t)
-    if t.is_a?(Array) && t.all? { |x| x.class == ErlangTransform::Tuple && x.length == 2 }
-      Hash[t.map { |i| [i[0], turn_to_hash(i[1])] }]
-    else
-      t
-    end
-  end
-end