inspec 2.0.32 → 2.0.45

data/lib/utils/filter.rb

@@ -1,272 +1,272 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Stephan Renatus
-# author: Christoph Hartmann
-
-module FilterTable
-  module Show; end
-
-  class ExceptionCatcher
-    def initialize(original_resource, original_exception)
-      @original_resource = original_resource
-      @original_exception = original_exception
-    end
-
-    # This method is called via the runner and signals RSpec to output a block
-    # showing why the resource was skipped. This prevents the resource from
-    # being added to the test collection and being evaluated.
-    def resource_skipped?
-      @original_exception.is_a?(Inspec::Exceptions::ResourceSkipped)
-    end
-
-    # This method is called via the runner and signals RSpec to output a block
-    # showing why the resource failed. This prevents the resource from
-    # being added to the test collection and being evaluated.
-    def resource_failed?
-      @original_exception.is_a?(Inspec::Exceptions::ResourceFailed)
-    end
-
-    def resource_exception_message
-      @original_exception.message
-    end
-
-    # Capture message chains and return `ExceptionCatcher` objects
-    def method_missing(*)
-      self
-    end
-
-    # RSpec will check the object returned to see if it responds to a method
-    # before calling it. We need to fake it out and tell it that it does. This
-    # allows it to skip past that check and fall through to #method_missing
-    def respond_to?(_method)
-      true
-    end
-
-    def to_s
-      @original_resource.to_s
-    end
-    alias inspect to_s
-  end
-
-  class Trace
-    def initialize
-      @chain = []
-    end
-
-    %w{== != >= > < <= =~ !~}.each do |m|
-      define_method m.to_sym do |*args|
-        res = Trace.new
-        @chain.push([[m.to_sym] + args, res])
-        res
-      end
-    end
-
-    def method_missing(*args)
-      res = Trace.new
-      @chain.push([args, res])
-      res
-    end
-
-    def self.to_ruby(trace)
-      chain = trace.instance_variable_get(:@chain)
-      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(' ')
-    end
-  end
-
-  class Table
-    attr_reader :params, :resource
-    def initialize(resource, params, filters)
-      @resource = resource
-      @params = params
-      @params = [] if @params.nil?
-      @filters = filters
-    end
-
-    def where(conditions = {}, &block)
-      return self if !conditions.is_a?(Hash)
-      return self if conditions.empty? && !block_given?
-
-      filters = ''
-      table = @params
-      conditions.each do |field, condition|
-        filters += " #{field} == #{condition.inspect}"
-        table = filter_lines(table, field, condition)
-      end
-
-      if block_given?
-        table = table.find_all { |e| new_entry(e, '').instance_eval(&block) }
-        src = Trace.new
-        src.instance_eval(&block)
-        filters += Trace.to_ruby(src)
-      end
-
-      self.class.new(@resource, table, @filters + filters)
-    end
-
-    def new_entry(*_)
-      raise "#{self.class} must not be used on its own. It must be inherited "\
-           'and the #new_entry method must be implemented. This is an internal '\
-           'error and should not happen.'
-    end
-
-    def entries
-      f = @resource.to_s + @filters.to_s + ' one entry'
-      @params.map do |line|
-        new_entry(line, f)
-      end
-    end
-
-    def get_field(field)
-      @params.map do |line|
-        line[field]
-      end
-    end
-
-    def to_s
-      @resource.to_s + @filters
-    end
-
-    alias inspect to_s
-
-    private
-
-    def matches_float(x, y)
-      return false if x.nil?
-      return false if !x.is_a?(Float) && (x =~ /\A[-+]?(\d+\.?\d*|\.\d+)\z/).nil?
-      x.to_f == y
-    end
-
-    def matches_int(x, y)
-      return false if x.nil?
-      return false if !x.is_a?(Integer) && (x =~ /\A[-+]?\d+\z/).nil?
-      x.to_i == y
-    end
-
-    def matches_regex(x, y)
-      return x == y if x.is_a?(Regexp)
-      !x.to_s.match(y).nil?
-    end
-
-    def matches(x, y)
-      x === y # rubocop:disable Style/CaseEquality
-    end
-
-    def filter_lines(table, field, condition)
-      m = case condition
-          when Float   then method(:matches_float)
-          when Integer then method(:matches_int)
-          when Regexp  then method(:matches_regex)
-          else              method(:matches)
-          end
-
-      table.find_all do |line|
-        next unless line.key?(field)
-        m.call(line[field], condition)
-      end
-    end
-  end
-
-  class Factory
-    Connector = Struct.new(:field_name, :block, :opts)
-
-    def initialize
-      @accessors = []
-      @connectors = {}
-    end
-
-    def connect(resource, table_accessor) # rubocop:disable Metrics/AbcSize
-      # create the table structure
-      connectors = @connectors
-      struct_fields = connectors.values.map(&:field_name)
-      connector_blocks = connectors.map do |method, c|
-        [method.to_sym, create_connector(c)]
-      end
-
-      # the struct to hold single items from the #entries method
-      entry_struct = Struct.new(*struct_fields.map(&:to_sym)) do
-        attr_accessor :__filter
-        def to_s
-          @__filter || super
-        end
-      end unless struct_fields.empty?
-
-      # the main filter table
-      table = Class.new(Table) {
-        connector_blocks.each do |x|
-          define_method x[0], &x[1]
-        end
-
-        define_method :new_entry do |hashmap, filter = ''|
-          return entry_struct.new if hashmap.nil?
-          res = entry_struct.new(*struct_fields.map { |x| hashmap[x] })
-          res.__filter = filter
-          res
-        end
-      }
-
-      # Define all access methods with the parent resource
-      # These methods will be configured to return an `ExceptionCatcher` object
-      # that will always return the original exception, but only when called
-      # upon. This will allow method chains in `describe` statements to pass the
-      # `instance_eval` when loaded and only throw-and-catch the exception when
-      # the tests are run.
-      accessors = @accessors + @connectors.keys
-      accessors.each do |method_name|
-        resource.send(:define_method, method_name.to_sym) do |*args, &block|
-          begin
-            filter = table.new(self, method(table_accessor).call, ' with')
-            filter.method(method_name.to_sym).call(*args, &block)
-          rescue Inspec::Exceptions::ResourceFailed, Inspec::Exceptions::ResourceSkipped => e
-            FilterTable::ExceptionCatcher.new(resource, e)
-          end
-        end
-      end
-    end
-
-    def add_accessor(method_name)
-      if method_name.nil?
-        throw RuntimeError, "Called filter.add_delegator for resource #{@resource} with method name nil!"
-      end
-      @accessors.push(method_name)
-      self
-    end
-
-    def add(method_name, opts = {}, &block)
-      if method_name.nil?
-        throw RuntimeError, "Called filter.add for resource #{@resource} with method name nil!"
-      end
-
-      @connectors[method_name.to_sym] =
-        Connector.new(opts[:field] || method_name, block, opts)
-      self
-    end
-
-    private
-
-    def create_connector(c)
-      return ->(cond = Show) { c.block.call(self, cond) } if !c.block.nil?
-
-      lambda { |condition = Show, &cond_block|
-        if condition == Show && !block_given?
-          r = where(nil).get_field(c.field_name)
-          r = r.flatten.uniq.compact if c.opts[:style] == :simple
-          r
-        else
-          where({ c.field_name => condition }, &cond_block)
-        end
-      }
-    end
-  end
-
-  def self.create
-    Factory.new
-  end
-end
+# encoding: utf-8
+# author: Dominik Richter
+# author: Stephan Renatus
+# author: Christoph Hartmann
+
+module FilterTable
+  module Show; end
+
+  class ExceptionCatcher
+    def initialize(original_resource, original_exception)
+      @original_resource = original_resource
+      @original_exception = original_exception
+    end
+
+    # This method is called via the runner and signals RSpec to output a block
+    # showing why the resource was skipped. This prevents the resource from
+    # being added to the test collection and being evaluated.
+    def resource_skipped?
+      @original_exception.is_a?(Inspec::Exceptions::ResourceSkipped)
+    end
+
+    # This method is called via the runner and signals RSpec to output a block
+    # showing why the resource failed. This prevents the resource from
+    # being added to the test collection and being evaluated.
+    def resource_failed?
+      @original_exception.is_a?(Inspec::Exceptions::ResourceFailed)
+    end
+
+    def resource_exception_message
+      @original_exception.message
+    end
+
+    # Capture message chains and return `ExceptionCatcher` objects
+    def method_missing(*)
+      self
+    end
+
+    # RSpec will check the object returned to see if it responds to a method
+    # before calling it. We need to fake it out and tell it that it does. This
+    # allows it to skip past that check and fall through to #method_missing
+    def respond_to?(_method)
+      true
+    end
+
+    def to_s
+      @original_resource.to_s
+    end
+    alias inspect to_s
+  end
+
+  class Trace
+    def initialize
+      @chain = []
+    end
+
+    %w{== != >= > < <= =~ !~}.each do |m|
+      define_method m.to_sym do |*args|
+        res = Trace.new
+        @chain.push([[m.to_sym] + args, res])
+        res
+      end
+    end
+
+    def method_missing(*args)
+      res = Trace.new
+      @chain.push([args, res])
+      res
+    end
+
+    def self.to_ruby(trace)
+      chain = trace.instance_variable_get(:@chain)
+      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(' ')
+    end
+  end
+
+  class Table
+    attr_reader :params, :resource
+    def initialize(resource, params, filters)
+      @resource = resource
+      @params = params
+      @params = [] if @params.nil?
+      @filters = filters
+    end
+
+    def where(conditions = {}, &block)
+      return self if !conditions.is_a?(Hash)
+      return self if conditions.empty? && !block_given?
+
+      filters = ''
+      table = @params
+      conditions.each do |field, condition|
+        filters += " #{field} == #{condition.inspect}"
+        table = filter_lines(table, field, condition)
+      end
+
+      if block_given?
+        table = table.find_all { |e| new_entry(e, '').instance_eval(&block) }
+        src = Trace.new
+        src.instance_eval(&block)
+        filters += Trace.to_ruby(src)
+      end
+
+      self.class.new(@resource, table, @filters + filters)
+    end
+
+    def new_entry(*_)
+      raise "#{self.class} must not be used on its own. It must be inherited "\
+           'and the #new_entry method must be implemented. This is an internal '\
+           'error and should not happen.'
+    end
+
+    def entries
+      f = @resource.to_s + @filters.to_s + ' one entry'
+      @params.map do |line|
+        new_entry(line, f)
+      end
+    end
+
+    def get_field(field)
+      @params.map do |line|
+        line[field]
+      end
+    end
+
+    def to_s
+      @resource.to_s + @filters
+    end
+
+    alias inspect to_s
+
+    private
+
+    def matches_float(x, y)
+      return false if x.nil?
+      return false if !x.is_a?(Float) && (x =~ /\A[-+]?(\d+\.?\d*|\.\d+)\z/).nil?
+      x.to_f == y
+    end
+
+    def matches_int(x, y)
+      return false if x.nil?
+      return false if !x.is_a?(Integer) && (x =~ /\A[-+]?\d+\z/).nil?
+      x.to_i == y
+    end
+
+    def matches_regex(x, y)
+      return x == y if x.is_a?(Regexp)
+      !x.to_s.match(y).nil?
+    end
+
+    def matches(x, y)
+      x === y # rubocop:disable Style/CaseEquality
+    end
+
+    def filter_lines(table, field, condition)
+      m = case condition
+          when Float   then method(:matches_float)
+          when Integer then method(:matches_int)
+          when Regexp  then method(:matches_regex)
+          else              method(:matches)
+          end
+
+      table.find_all do |line|
+        next unless line.key?(field)
+        m.call(line[field], condition)
+      end
+    end
+  end
+
+  class Factory
+    Connector = Struct.new(:field_name, :block, :opts)
+
+    def initialize
+      @accessors = []
+      @connectors = {}
+    end
+
+    def connect(resource, table_accessor) # rubocop:disable Metrics/AbcSize
+      # create the table structure
+      connectors = @connectors
+      struct_fields = connectors.values.map(&:field_name)
+      connector_blocks = connectors.map do |method, c|
+        [method.to_sym, create_connector(c)]
+      end
+
+      # the struct to hold single items from the #entries method
+      entry_struct = Struct.new(*struct_fields.map(&:to_sym)) do
+        attr_accessor :__filter
+        def to_s
+          @__filter || super
+        end
+      end unless struct_fields.empty?
+
+      # the main filter table
+      table = Class.new(Table) {
+        connector_blocks.each do |x|
+          define_method x[0], &x[1]
+        end
+
+        define_method :new_entry do |hashmap, filter = ''|
+          return entry_struct.new if hashmap.nil?
+          res = entry_struct.new(*struct_fields.map { |x| hashmap[x] })
+          res.__filter = filter
+          res
+        end
+      }
+
+      # Define all access methods with the parent resource
+      # These methods will be configured to return an `ExceptionCatcher` object
+      # that will always return the original exception, but only when called
+      # upon. This will allow method chains in `describe` statements to pass the
+      # `instance_eval` when loaded and only throw-and-catch the exception when
+      # the tests are run.
+      accessors = @accessors + @connectors.keys
+      accessors.each do |method_name|
+        resource.send(:define_method, method_name.to_sym) do |*args, &block|
+          begin
+            filter = table.new(self, method(table_accessor).call, ' with')
+            filter.method(method_name.to_sym).call(*args, &block)
+          rescue Inspec::Exceptions::ResourceFailed, Inspec::Exceptions::ResourceSkipped => e
+            FilterTable::ExceptionCatcher.new(resource, e)
+          end
+        end
+      end
+    end
+
+    def add_accessor(method_name)
+      if method_name.nil?
+        throw RuntimeError, "Called filter.add_delegator for resource #{@resource} with method name nil!"
+      end
+      @accessors.push(method_name)
+      self
+    end
+
+    def add(method_name, opts = {}, &block)
+      if method_name.nil?
+        throw RuntimeError, "Called filter.add for resource #{@resource} with method name nil!"
+      end
+
+      @connectors[method_name.to_sym] =
+        Connector.new(opts[:field] || method_name, block, opts)
+      self
+    end
+
+    private
+
+    def create_connector(c)
+      return ->(cond = Show) { c.block.call(self, cond) } if !c.block.nil?
+
+      lambda { |condition = Show, &cond_block|
+        if condition == Show && !block_given?
+          r = where(nil).get_field(c.field_name)
+          r = r.flatten.uniq.compact if c.opts[:style] == :simple
+          r
+        else
+          where({ c.field_name => condition }, &cond_block)
+        end
+      }
+    end
+  end
+
+  def self.create
+    Factory.new
+  end
+end