inspec 2.1.80 → 2.1.81

data/lib/utils/pkey_reader.rb

@@ -1,15 +1,15 @@
-module PkeyReader
-  def read_pkey(filecontent, passphrase)
-    raise_if_default(passphrase)
-
-    OpenSSL::PKey.read(filecontent, passphrase)
-  rescue OpenSSL::PKey::PKeyError
-    raise Inspec::Exceptions::ResourceFailed, 'passphrase error'
-  end
-
-  def raise_if_default(passphrase)
-    if passphrase.is_a? Inspec::Attribute::DEFAULT_ATTRIBUTE
-      raise Inspec::Exceptions::ResourceFailed, 'Please provide default value for attribute'
-    end
-  end
-end
+module PkeyReader
+  def read_pkey(filecontent, passphrase)
+    raise_if_default(passphrase)
+
+    OpenSSL::PKey.read(filecontent, passphrase)
+  rescue OpenSSL::PKey::PKeyError
+    raise Inspec::Exceptions::ResourceFailed, 'passphrase error'
+  end
+
+  def raise_if_default(passphrase)
+    if passphrase.is_a? Inspec::Attribute::DEFAULT_ATTRIBUTE
+      raise Inspec::Exceptions::ResourceFailed, 'Please provide default value for attribute'
+    end
+  end
+end

data/lib/utils/plugin_registry.rb

@@ -1,93 +1,93 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-class PluginRegistry
-  attr_reader :registry
-
-  def initialize
-    @registry = {}
-  end
-
-  # Resolve a target via available plugins.
-  #
-  # @param [String] target to resolve
-  # @return [Plugin] plugin instance if it can be resolved, nil otherwise
-  def resolve(target)
-    modules.each do |m|
-      res = m.resolve(target)
-      return res unless res.nil?
-    end
-    nil
-  end
-
-  private
-
-  # Get all registered plugins sorted by priority, with highest first
-  #
-  # @return [Array[Plugin]] sorted list of plugins
-  def modules
-    @registry.values
-             .sort_by { |x| x.respond_to?(:priority) ? x.priority : 0 }
-             .reverse
-  end
-end
-
-class PluginRegistry
-  class Plugin
-    # Retrieve the plugin registry associated with this plugin
-    #
-    # @return [PluginRegistry] plugin registry for this plugin
-    def self.plugin_registry
-      raise "Plugin #{self} does not implement `self.plugin_registry()`. This method is required"
-    end
-
-    # Register a new plugin by name
-    #
-    # @param [String] the unique name of this plugin
-    # @return [nil] disregard
-    def self.name(name)
-      raise "Trying to register #{self} with name == nil" if name.nil?
-      @name = name
-      plugin_registry.registry[name] = self
-    end
-
-    # This plugin's priority. Set it by providing the priority as an
-    # argument. Higher numbers ensure that the plugin is
-    # called early to check if a target belongs to it. When called without
-    # an argument, it retrieves this plugin's priority. Defaults to 0.
-    #
-    # @param [Numeric] Priority as a number. Will only be set if != nil
-    # @return [Numeric] This plugin's priority
-    def self.priority(x = nil)
-      @priority = x unless x.nil?
-      @priority || 0
-    end
-
-    # Try to resolve the target. If this plugin cannot handle it, the result
-    # will be nil. If, however, the plugin can resolve it, the resulting
-    # object will be an instance of this plugin. This means, that the interface
-    # that this base class provides, is the basis for the returned type.
-    #
-    # @param [String] target to try to resolve
-    # @return [Plugin] instance if it can be resolved, nil otherwise
-    def self.resolve(_target)
-      raise "Plugin #{self} does not implement `self.resolve(target)`. This method is required"
-    end
-
-    # When a plugin's resolve doesn't lead to the final state, it can
-    # use this method to hand it back for another resolver to handle.
-    #
-    # @param [Any] the current target that needs resolving
-    # @param [Plugin] an instance of the calling resolver
-    # @return [Plugin] instance if it can be resolved, nil otherwise
-    def self.resolve_next(target, parent)
-      res = plugin_registry.resolve(target)
-      res.parent = parent
-      res
-    end
-
-    attr_reader :target
-    attr_accessor :parent
-  end
-end
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+class PluginRegistry
+  attr_reader :registry
+
+  def initialize
+    @registry = {}
+  end
+
+  # Resolve a target via available plugins.
+  #
+  # @param [String] target to resolve
+  # @return [Plugin] plugin instance if it can be resolved, nil otherwise
+  def resolve(target)
+    modules.each do |m|
+      res = m.resolve(target)
+      return res unless res.nil?
+    end
+    nil
+  end
+
+  private
+
+  # Get all registered plugins sorted by priority, with highest first
+  #
+  # @return [Array[Plugin]] sorted list of plugins
+  def modules
+    @registry.values
+             .sort_by { |x| x.respond_to?(:priority) ? x.priority : 0 }
+             .reverse
+  end
+end
+
+class PluginRegistry
+  class Plugin
+    # Retrieve the plugin registry associated with this plugin
+    #
+    # @return [PluginRegistry] plugin registry for this plugin
+    def self.plugin_registry
+      raise "Plugin #{self} does not implement `self.plugin_registry()`. This method is required"
+    end
+
+    # Register a new plugin by name
+    #
+    # @param [String] the unique name of this plugin
+    # @return [nil] disregard
+    def self.name(name)
+      raise "Trying to register #{self} with name == nil" if name.nil?
+      @name = name
+      plugin_registry.registry[name] = self
+    end
+
+    # This plugin's priority. Set it by providing the priority as an
+    # argument. Higher numbers ensure that the plugin is
+    # called early to check if a target belongs to it. When called without
+    # an argument, it retrieves this plugin's priority. Defaults to 0.
+    #
+    # @param [Numeric] Priority as a number. Will only be set if != nil
+    # @return [Numeric] This plugin's priority
+    def self.priority(x = nil)
+      @priority = x unless x.nil?
+      @priority || 0
+    end
+
+    # Try to resolve the target. If this plugin cannot handle it, the result
+    # will be nil. If, however, the plugin can resolve it, the resulting
+    # object will be an instance of this plugin. This means, that the interface
+    # that this base class provides, is the basis for the returned type.
+    #
+    # @param [String] target to try to resolve
+    # @return [Plugin] instance if it can be resolved, nil otherwise
+    def self.resolve(_target)
+      raise "Plugin #{self} does not implement `self.resolve(target)`. This method is required"
+    end
+
+    # When a plugin's resolve doesn't lead to the final state, it can
+    # use this method to hand it back for another resolver to handle.
+    #
+    # @param [Any] the current target that needs resolving
+    # @param [Plugin] an instance of the calling resolver
+    # @return [Plugin] instance if it can be resolved, nil otherwise
+    def self.resolve_next(target, parent)
+      res = plugin_registry.resolve(target)
+      res.parent = parent
+      res
+    end
+
+    attr_reader :target
+    attr_accessor :parent
+  end
+end

data/lib/utils/simpleconfig.rb

@@ -1,120 +1,120 @@
-# encoding: utf-8
-# copyright: 2015, Dominik Richter
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'utils/parser'
-
-class SimpleConfig
-  include CommentParser
-
-  attr_reader :params, :groups
-  def initialize(raw_data, opts = {})
-    parse(raw_data, opts)
-  end
-
-  # Parse some data
-  # quotes: quoting characters, which are parsed, so everything inside
-  # it will be part of a string
-  # multiline: allow quoted text to span multiple lines
-  # comment_char: char which identifies comments
-  # standalone_comments: comments must appear alone in a line; if set to true,
-  # no comments can be added to the end of an assignment/statement line
-  def parse(raw_data, opts = nil)
-    @params = {}
-    @groups = []
-    @vals = @params
-    options = default_options.merge(opts || {})
-    return if raw_data.nil?
-
-    # prepare raw data if required
-    if !options[:line_separator].nil?
-      raw_data = raw_data.tr(options[:line_separator], "\n")
-    end
-    rest = raw_data
-    rest = parse_rest(rest, options) until rest.empty?
-  end
-
-  private
-
-  def parse_values(match, values)
-    start_idx = 2
-    i = 0
-    count = values - 1
-    return match[start_idx] if values == 1
-
-    # iterate over expected parameters
-    values = []
-    loop do
-      values.push(match[start_idx + i])
-      i += 1
-      break if i > count
-    end
-    values
-  end
-
-  def parse_params_line(line, opts)
-    # now line contains what we are interested in parsing
-    # check if it is an assignment
-    m = opts[:assignment_regex].match(line)
-    return nil if m.nil?
-
-    if opts[:multiple_values]
-      @vals[m[1]] ||= []
-      @vals[m[1]].push(parse_values(m, opts[:key_values]))
-    else
-      @vals[m[1]] = parse_values(m, opts[:key_values])
-    end
-  end
-
-  def parse_group_line(line, opts)
-    return nil if opts[:group_re].nil?
-    m = opts[:group_re].match(line)
-    return nil if m.nil?
-    @groups.push(m[1])
-
-    # We use a Hashie::Mash to provide method syntax for retrieving
-    # values. For configs that have keys whose values may be hashes
-    # (such as a mysql config that has [sections]), providing
-    # a hash whose values are accessible via methods provide
-    # a better user experience with `its` blocks.
-    @vals = @params[m[1]] = Hashie::Mash.new
-  end
-
-  def parse_implicit_assignment_line(line, opts)
-    return nil if is_empty_line(line)
-    if opts[:multiple_values]
-      @vals[line.strip] ||= []
-    else
-      @vals[line.strip] = ''
-    end
-  end
-
-  def parse_rest(rest, opts)
-    line, idx_nl = parse_comment_line(rest, opts)
-    parse_params_line(line, opts) or
-      parse_group_line(line, opts) or
-      parse_implicit_assignment_line(line, opts)
-
-    # return whatever is left
-    rest[(idx_nl + 1)..-1] || ''
-  end
-
-  def is_empty_line(l)
-    l =~ /^\s*$/
-  end
-
-  def default_options
-    {
-      quotes: '',
-      multiline: false,
-      comment_char: '#',
-      line_separator: nil, # uses this char to seperate lines before parsing
-      assignment_regex: /^\s*([^=]*?)\s*=\s*(.*?)\s*$/,
-      group_re: /\[([^\]]+)\]\s*$/,
-      key_values: 1, # default for key=value, may require for 'key val1 val2 val3'
-      standalone_comments: false,
-      multiple_values: false,
-    }
-  end
-end
+# encoding: utf-8
+# copyright: 2015, Dominik Richter
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'utils/parser'
+
+class SimpleConfig
+  include CommentParser
+
+  attr_reader :params, :groups
+  def initialize(raw_data, opts = {})
+    parse(raw_data, opts)
+  end
+
+  # Parse some data
+  # quotes: quoting characters, which are parsed, so everything inside
+  # it will be part of a string
+  # multiline: allow quoted text to span multiple lines
+  # comment_char: char which identifies comments
+  # standalone_comments: comments must appear alone in a line; if set to true,
+  # no comments can be added to the end of an assignment/statement line
+  def parse(raw_data, opts = nil)
+    @params = {}
+    @groups = []
+    @vals = @params
+    options = default_options.merge(opts || {})
+    return if raw_data.nil?
+
+    # prepare raw data if required
+    if !options[:line_separator].nil?
+      raw_data = raw_data.tr(options[:line_separator], "\n")
+    end
+    rest = raw_data
+    rest = parse_rest(rest, options) until rest.empty?
+  end
+
+  private
+
+  def parse_values(match, values)
+    start_idx = 2
+    i = 0
+    count = values - 1
+    return match[start_idx] if values == 1
+
+    # iterate over expected parameters
+    values = []
+    loop do
+      values.push(match[start_idx + i])
+      i += 1
+      break if i > count
+    end
+    values
+  end
+
+  def parse_params_line(line, opts)
+    # now line contains what we are interested in parsing
+    # check if it is an assignment
+    m = opts[:assignment_regex].match(line)
+    return nil if m.nil?
+
+    if opts[:multiple_values]
+      @vals[m[1]] ||= []
+      @vals[m[1]].push(parse_values(m, opts[:key_values]))
+    else
+      @vals[m[1]] = parse_values(m, opts[:key_values])
+    end
+  end
+
+  def parse_group_line(line, opts)
+    return nil if opts[:group_re].nil?
+    m = opts[:group_re].match(line)
+    return nil if m.nil?
+    @groups.push(m[1])
+
+    # We use a Hashie::Mash to provide method syntax for retrieving
+    # values. For configs that have keys whose values may be hashes
+    # (such as a mysql config that has [sections]), providing
+    # a hash whose values are accessible via methods provide
+    # a better user experience with `its` blocks.
+    @vals = @params[m[1]] = Hashie::Mash.new
+  end
+
+  def parse_implicit_assignment_line(line, opts)
+    return nil if is_empty_line(line)
+    if opts[:multiple_values]
+      @vals[line.strip] ||= []
+    else
+      @vals[line.strip] = ''
+    end
+  end
+
+  def parse_rest(rest, opts)
+    line, idx_nl = parse_comment_line(rest, opts)
+    parse_params_line(line, opts) or
+      parse_group_line(line, opts) or
+      parse_implicit_assignment_line(line, opts)
+
+    # return whatever is left
+    rest[(idx_nl + 1)..-1] || ''
+  end
+
+  def is_empty_line(l)
+    l =~ /^\s*$/
+  end
+
+  def default_options
+    {
+      quotes: '',
+      multiline: false,
+      comment_char: '#',
+      line_separator: nil, # uses this char to seperate lines before parsing
+      assignment_regex: /^\s*([^=]*?)\s*=\s*(.*?)\s*$/,
+      group_re: /\[([^\]]+)\]\s*$/,
+      key_values: 1, # default for key=value, may require for 'key val1 val2 val3'
+      standalone_comments: false,
+      multiple_values: false,
+    }
+  end
+end