inspec-core 4.3.2 → 4.6.3

data/lib/{utils → inspec/utils}/deprecation/deprecator.rb

@@ -1,5 +1,5 @@
-require 'utils/deprecation/config_file'
-require 'inspec/log'
+require "inspec/utils/deprecation/config_file"
+require "inspec/log"
 
 module Inspec
   module Deprecation
@@ -17,7 +17,7 @@ module Inspec
         assembled_message = assemble_message(message, group, opts)
 
         action = group[:action] || :warn
-        action_method = ('handle_' + action.to_s + '_action').to_sym
+        action_method = ("handle_" + action.to_s + "_action").to_sym
         send(action_method, group_name.to_sym, assembled_message, group)
       end
 
@@ -44,24 +44,24 @@ module Inspec
         # rspec-core surrounds these.
 
         # First, purge the deprecation system frames
-        stack.reject! { |frame| frame.path && frame.path =~ %r{lib/utils/deprecation} }
+        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' }
+        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?
+        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)
+        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
+        "DEPRECATION: " + prefix + message + suffix
       end
 
       def called_from_control?
@@ -70,7 +70,7 @@ module Inspec
 
         # 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')
+          return true if frame.path.end_with?("rspec/core/example_group.rb")
         end
 
         false

data/lib/{utils → inspec/utils}/deprecation/errors.rb

@@ -1,4 +1,4 @@
-require 'inspec/errors'
+require "inspec/errors"
 
 module Inspec
   module Deprecation

data/lib/{utils → inspec/utils}/deprecation/global_method.rb

@@ -1,7 +1,7 @@
-require 'utils/deprecation/deprecator'
+require "inspec/utils/deprecation/deprecator"
 
 module Inspec
-  def self.deprecate(group, msg = '', opts = {})
+  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)

data/lib/{utils → inspec/utils}/enumerable_delegation.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module EnumerableDelegation
   include Enumerable
 

data/lib/{utils → inspec/utils}/erlang_parser.rb

@@ -1,109 +1,105 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'parslet'
+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) {
+  rule(:exp) do
     (tuple | array | binary | string | bool | identifier | float | integer) >> filler?
-  }
+  end
 
-  rule(:array) {
-    str('[') >> filler? >> (
+  rule(:array) do
+    str("[") >> filler? >> (
       exp.repeat(1) >>
       (comma >> exp).repeat
-    ).maybe.as(:array) >> str(']') >> filler?
-  }
+    ).maybe.as(:array) >> str("]") >> filler?
+  end
 
-  rule(:tuple) {
-    str('{') >> filler? >> (
+  rule(:tuple) do
+    str("{") >> filler? >> (
       exp.repeat(1) >> filler? >>
       (comma >> exp).repeat
-    ).maybe.as(:tuple) >> str('}') >> filler?
-  }
+    ).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(: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) {
-    (match('[a-zA-Z]') >> match('[a-zA-Z0-9_]').repeat).as(:identifier) >> filler?
-  }
+  rule(:identifier) do
+    (match("[a-zA-Z]") >> match("[a-zA-Z0-9_]").repeat).as(:identifier) >> filler?
+  end
 
-  rule(:float) {
+  rule(:float) do
     (
       integer >> (
-        str('.') >> match('[0-9]').repeat(1) |
-        str('e') >> match('[0-9]').repeat(1)
+        str(".") >> match("[0-9]").repeat(1) |
+        str("e") >> match("[0-9]").repeat(1)
       ).as(:e)
     ).as(:float) >> filler?
-  }
+  end
 
-  rule(:integer) {
-    ((str('+') | str('-')).maybe >> match('[0-9]').repeat(1)).as(:integer) >> filler?
-  }
+  rule(:integer) do
+    ((str("+") | str("-")).maybe >> match("[0-9]").repeat(1)).as(:integer) >> filler?
+  end
 
   rule(:string) { stringS | stringD }
 
-  rule(:stringS) {
+  rule(:stringS) do
     str("'") >> (
       str('\\') >> any | str("'").absent? >> any
     ).repeat.as(:string) >> str("'") >> filler?
-  }
+  end
 
-  rule(:stringD) {
+  rule(:stringD) do
     str('"') >> (
       str('\\') >> any | str('"').absent? >> any
     ).repeat.as(:string) >> str('"') >> filler?
-  }
+  end
 
-  rule(:binary_item) {
+  rule(:binary_item) do
     (string | integer) >>
-      (str(':') >> integer).maybe.as(:size) >>
-      (str('/') >> identifier).maybe.as(:type) >>
+      (str(":") >> integer).maybe.as(:size) >>
+      (str("/") >> identifier).maybe.as(:type) >>
       filler?
-  }
+  end
 
-  rule(:binary) {
-    str('<<') >> filler? >> (
+  rule(:binary) do
+    str("<<") >> filler? >> (
       binary_item.repeat(1) >>
       (comma >> binary_item).repeat
-    ).maybe.as(:binary) >> str('>>') >> filler?
-  }
+    ).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...
+    @cur_bits = "" # a string of binary bits 10010010...
   end
 
   TYPES = {
-    'integer' => 8,
-    'float'   => 8*8,
-    'utf8'    => 8,
-    'utf16'   => 8*2,
-    'utf32'   => 8*4,
+    "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?
+    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!'
+      raise "No data provided, internal error for binary-stream processing!"
     end
     s = bit_size(i[:size], i[:type])
     unless i[:string].nil?
@@ -112,17 +108,17 @@ class ErlangBitstream
       add_int(i[:integer], s)
     end
   rescue RuntimeError => e
-    raise 'Error processing Erlang bit string '\
+    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 }
+    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
 
@@ -141,11 +137,11 @@ class ErlangBitstream
     @cur_bits = b.last
   end
 
-  def value(encoding = 'utf-8')
+  def value(encoding = "utf-8")
     # fill in the rest
-    rest = '0' * (8 - @cur_bits.length) + @cur_bits
+    rest = "0" * (8 - @cur_bits.length) + @cur_bits
     arr = @data + [rest.to_i(2)]
-    s = arr.pack('C*')
+    s = arr.pack("C*")
     s.force_encoding(encoding) unless encoding.nil?
     s
   end
@@ -162,17 +158,17 @@ class ErlangTransform < Parslet::Transform
   end
 
   rule(string: simple(:x)) { x.to_s }
-  rule(string: []) { '' }
+  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(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)) {
+  rule(tuple: subtree(:x)) do
     x.nil? ? Tuple.new : Tuple.new(x)
-  }
+  end
 end
 
 class ErlangConfigFile

data/lib/{utils → inspec/utils}/file_reader.rb

@@ -1,5 +1,4 @@
-# encoding: utf-8
-# author: ERAMOTO Masaya
+require "inspec/resources/file"
 
 module FileReader
   def read_file_content(path, allow_empty = false)

data/lib/{utils → inspec/utils}/filter.rb

@@ -1,8 +1,3 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Stephan Renatus
-# author: Christoph Hartmann
-
 module FilterTable
   # This is used as a sentinel value in custom property filtering
   module NoCriteriaProvided; end
@@ -70,15 +65,15 @@ module FilterTable
 
     def self.to_ruby(trace)
       chain = trace.instance_variable_get(:@chain)
-      return '' if chain.empty?
-      ' ' + chain.map do |el|
+      return "" if chain.empty?
+      " " + chain.map do |el|
         m = el[0][0]
         args = el[0].drop(1)
         nxt = to_ruby(el[1])
         next m.to_s + nxt if args.empty?
-        next m.to_s + ' ' + args[0].inspect + nxt if args.length == 1
-        m.to_s + '(' + args.map(&:inspect).join(', ') + ')' + nxt
-      end.join(' ')
+        next m.to_s + " " + args[0].inspect + nxt if args.length == 1
+        m.to_s + "(" + args.map(&:inspect).join(", ") + ")" + nxt
+      end.join(" ")
     end
   end
 
@@ -117,7 +112,7 @@ module FilterTable
       # against the struct.
       if block_given?
         # Perform the filtering.
-        filtered_raw_data = filtered_raw_data.find_all { |row_as_hash| create_eval_context_for_row(row_as_hash, '').instance_eval(&block) }
+        filtered_raw_data = filtered_raw_data.find_all { |row_as_hash| create_eval_context_for_row(row_as_hash, "").instance_eval(&block) }
         # Try to interpret the block for updating the stringification.
         src = Trace.new
         # Swallow any exceptions raised here.
@@ -139,8 +134,8 @@ module FilterTable
 
     def create_eval_context_for_row(*_)
       raise "#{self.class} must not be used on its own. It must be inherited "\
-           'and the #create_eval_context_for_row method must be implemented. This is an internal '\
-           'error and should not happen.'
+           "and the #create_eval_context_for_row method must be implemented. This is an internal "\
+           "error and should not happen."
     end
 
     def resource
@@ -153,7 +148,7 @@ module FilterTable
     end
 
     def entries
-      row_criteria_string = resource.to_s + criteria_string + ' one entry'
+      row_criteria_string = resource.to_s + criteria_string + " one entry"
       raw_data.map do |row|
         create_eval_context_for_row(row, row_criteria_string)
       end
@@ -251,10 +246,10 @@ module FilterTable
       return [] if current_raw_data.empty?
 
       method_ref = case desired_value
-                   when Float   then method(:matches_float)
-                   when Integer then method(:matches_int)
-                   when Regexp  then method(:matches_regex)
-                   else              method(:matches)
+                   when Float   then :matches_float
+                   when Integer then :matches_int
+                   when Regexp  then :matches_regex
+                   else              :matches
                    end
 
       assume_symbolic_keyed_data = current_raw_data.first.keys.first.is_a? Symbol
@@ -262,14 +257,14 @@ module FilterTable
 
       current_raw_data.find_all do |row|
         next unless row.key?(field)
-        method_ref.call(row[field], desired_value)
+        send(method_ref, row[field], desired_value)
       end
     end
 
     def decorate_symbols(thing)
       return thing.map { |t| decorate_symbols(t) } if thing.is_a?(Array)
-      return ':' + thing.to_s if thing.is_a? Symbol
-      return thing + ' (String)' if thing.is_a? String
+      return ":" + thing.to_s if thing.is_a? Symbol
+      return thing + " (String)" if thing.is_a? String
       thing
     end
   end
@@ -289,13 +284,15 @@ module FilterTable
     def install_filter_methods_on_resource(resource_class, raw_data_fetcher_method_name) # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
       # A context in which you can access the fields as accessors
       non_block_struct_fields = @custom_properties.values.reject(&:block).map(&:field_name)
-      row_eval_context_type = Struct.new(*non_block_struct_fields.map(&:to_sym)) do
-        attr_accessor :criteria_string
-        attr_accessor :filter_table
-        def to_s
-          @criteria_string || super
+      unless non_block_struct_fields.empty?
+        row_eval_context_type = Struct.new(*non_block_struct_fields.map(&:to_sym)) do
+          attr_accessor :criteria_string
+          attr_accessor :filter_table
+          def to_s
+            @criteria_string || super
+          end
         end
-      end unless non_block_struct_fields.empty?
+      end
 
       properties_to_define = @custom_properties.map do |method_name, custom_property_structure|
         { method_name: method_name, method_body: create_custom_property_body(custom_property_structure) }
@@ -303,7 +300,7 @@ module FilterTable
 
       # Define the filter table subclass
       custom_properties = @custom_properties # We need a local var, not an instance var, for a closure below
-      table_class = Class.new(Table) {
+      table_class = Class.new(Table) do
         # Install each custom property onto the FilterTable subclass
         properties_to_define.each do |property_info|
           define_method property_info[:method_name], &property_info[:method_body]
@@ -314,14 +311,14 @@ module FilterTable
         end
 
         # Install a method that can wrap all the fields into a context with accessors
-        define_method :create_eval_context_for_row do |row_as_hash, criteria_string = ''|
+        define_method :create_eval_context_for_row do |row_as_hash, criteria_string = ""|
           return row_eval_context_type.new if row_as_hash.nil?
           context = row_eval_context_type.new(*non_block_struct_fields.map { |field| row_as_hash[field] })
           context.criteria_string = criteria_string
           context.filter_table = self
           context
         end
-      }
+      end
 
       # Now that the table class is defined and the row eval context struct is defined,
       # extend the row eval context struct to support triggering population of lazy fields
@@ -356,11 +353,11 @@ module FilterTable
       # the tests are run.
       methods_to_install_on_resource_class = @filter_methods + @custom_properties.keys
       methods_to_install_on_resource_class.each do |method_name|
-        resource_class.send(:define_method, method_name.to_sym) do |*args, &block|
+        resource_class.send(:define_method, method_name) do |*args, &block|
           begin
             # self here is the resource instance
-            filter_table_instance = table_class.new(self, method(raw_data_fetcher_method_name).call, ' with')
-            filter_table_instance.method(method_name.to_sym).call(*args, &block)
+            filter_table_instance = table_class.new(self, send(raw_data_fetcher_method_name), " with")
+            filter_table_instance.send(method_name, *args, &block)
           rescue Inspec::Exceptions::ResourceFailed, Inspec::Exceptions::ResourceSkipped => e
             FilterTable::ExceptionCatcher.new(resource_class, e)
           end