inspec 4.18.51 → 4.18.85

data/lib/inspec/resources/ntp_conf.rb

@@ -1,51 +0,0 @@
-# copyright: 2015, Vulcano Security GmbH
-
-require "inspec/utils/simpleconfig"
-require "inspec/utils/file_reader"
-
-module Inspec::Resources
-  class NtpConf < Inspec.resource(1)
-    name "ntp_conf"
-    supports platform: "unix"
-    desc "Use the ntp_conf InSpec audit resource to test the synchronization settings defined in the ntp.conf file. This file is typically located at /etc/ntp.conf."
-    example <<~EXAMPLE
-      describe ntp_conf do
-        its('server') { should_not eq nil }
-        its('restrict') { should include '-4 default kod notrap nomodify nopeer noquery'}
-      end
-    EXAMPLE
-
-    include FileReader
-
-    def initialize(path = nil)
-      @conf_path = path || "/etc/ntp.conf"
-      @content = read_file_content(@conf_path)
-    end
-
-    def method_missing(name)
-      param = read_params[name.to_s]
-      # extract first value if we have only one value in array
-      return param[0] if param.is_a?(Array) && (param.length == 1)
-
-      param
-    end
-
-    def to_s
-      "ntp.conf"
-    end
-
-    private
-
-    def read_params
-      return @params if defined?(@params)
-
-      # parse the file
-      conf = SimpleConfig.new(
-        @content,
-        assignment_regex: /^\s*(\S+)\s+(.*)\s*$/,
-        multiple_values: true
-      )
-      @params = conf.params
-    end
-  end
-end

data/lib/inspec/resources/oneget.rb

@@ -1,71 +0,0 @@
-require "inspec/resources/command"
-
-# This resource talks with OneGet (https://github.com/OneGet/oneget)
-# Its part of Windows Management Framework 5.0 and part of Windows 10
-#
-# Usage:
-# describe oneget('zoomit') do
-#   it { should be_installed }
-# end
-module Inspec::Resources
-  class OneGetPackage < Inspec.resource(1)
-    name "oneget"
-    supports platform: "windows"
-    desc "Use the oneget InSpec audit resource to test if the named package and/or package version is installed on the system. This resource uses OneGet, which is part of the Windows Management Framework 5.0 and Windows 10. This resource uses the Get-Package cmdlet to return all of the package names in the OneGet repository."
-    example <<~EXAMPLE
-      describe oneget('zoomit') do
-        it { should be_installed }
-        its('version') { should eq '1.2.3' }
-      end
-    EXAMPLE
-
-    def initialize(package_name)
-      @package_name = package_name
-
-      # verify that this resource is only supported on Windows
-      return skip_resource "The `oneget` resource is not supported on your OS." unless inspec.os.windows?
-    end
-
-    def info
-      return @info if defined?(@info)
-
-      @info = {}
-      @info[:type] = "oneget"
-      @info[:installed] = false
-
-      cmd = inspec.command("Get-Package -Name '#{@package_name}' | ConvertTo-Json")
-      # cannot rely on exit code for now, successful command returns exit code 1
-      # return nil if cmd.exit_status != 0
-      # try to parse json
-
-      begin
-        pkgs = JSON.parse(cmd.stdout)
-        @info[:installed] = true
-
-        # sometimes we get multiple values
-        if pkgs.is_a?(Array)
-          # select the first entry
-          pkgs = pkgs.first
-        end
-      rescue JSON::ParserError => _e
-        return @info
-      end
-
-      @info[:name] = pkgs["Name"] if pkgs.key?("Name")
-      @info[:version] = pkgs["Version"] if pkgs.key?("Version")
-      @info
-    end
-
-    def installed?
-      info[:installed] == true
-    end
-
-    def version
-      info[:version]
-    end
-
-    def to_s
-      "OneGet Package #{@package_name}"
-    end
-  end
-end

data/lib/inspec/resources/oracledb_session.rb

@@ -1,149 +0,0 @@
-require "inspec/resources/command"
-require "inspec/utils/database_helpers"
-require "htmlentities"
-require "rexml/document"
-require "hashie/mash"
-require "csv"
-
-module Inspec::Resources
-  # STABILITY: Experimental
-  # This resource needs further testing and refinement
-  #
-  class OracledbSession < Inspec.resource(1)
-    name "oracledb_session"
-    supports platform: "unix"
-    supports platform: "windows"
-    desc "Use the oracledb_session InSpec resource to test commands against an Oracle database"
-    example <<~EXAMPLE
-      sql = oracledb_session(user: 'my_user', pass: 'password')
-      describe sql.query(\"SELECT UPPER(VALUE) AS VALUE FROM V$PARAMETER WHERE UPPER(NAME)='AUDIT_SYS_OPERATIONS'\").row(0).column('value') do
-        its('value') { should eq 'TRUE' }
-      end
-    EXAMPLE
-
-    attr_reader :bin, :db_role, :host, :password, :port, :service,
-                :su_user, :user
-
-    def initialize(opts = {})
-      @user = opts[:user]
-      @password = opts[:password] || opts[:pass]
-      if opts[:pass]
-        Inspec.deprecate(:oracledb_session_pass_option, "The oracledb_session `pass` option is deprecated. Please use `password`.")
-      end
-
-      @bin = "sqlplus"
-      @host = opts[:host] || "localhost"
-      @port = opts[:port] || "1521"
-      @service = opts[:service]
-      @su_user = opts[:as_os_user]
-      @db_role = opts[:as_db_role]
-      @sqlcl_bin = opts[:sqlcl_bin] || nil
-      @sqlplus_bin = opts[:sqlplus_bin] || "sqlplus"
-      skip_resource "Option 'as_os_user' not available in Windows" if inspec.os.windows? && su_user
-      fail_resource "Can't run Oracle checks without authentication" unless su_user && (user || password)
-      fail_resource "You must provide a service name for the session" unless service
-    end
-
-    def query(sql)
-      if @sqlcl_bin && inspec.command(@sqlcl_bin).exist?
-        @bin = @sqlcl_bin
-        format_options = "set sqlformat csv\nSET FEEDBACK OFF"
-        parser = :parse_csv_result
-      else
-        @bin = "#{@sqlplus_bin} -S"
-        format_options = "SET MARKUP HTML ON\nSET PAGESIZE 32000\nSET FEEDBACK OFF"
-        parser = :parse_html_result
-      end
-
-      command = command_builder(format_options, sql)
-      inspec_cmd = inspec.command(command)
-
-      DatabaseHelper::SQLQueryResult.new(inspec_cmd,
-                                         send(parser, inspec_cmd.stdout))
-    end
-
-    def to_s
-      "Oracle Session"
-    end
-
-    private
-
-    # 3 commands
-    # regular user password
-    # using a db_role
-    # su, using a db_role
-    def command_builder(format_options, query)
-      verified_query = verify_query(query)
-      sql_prefix, sql_postfix = "", ""
-      if inspec.os.windows?
-        sql_prefix = %{@'\n#{format_options}\n#{verified_query}\nEXIT\n'@ | }
-      else
-        sql_postfix = %{ <<'EOC'\n#{format_options}\n#{verified_query}\nEXIT\nEOC}
-      end
-
-      if @db_role.nil?
-        %{#{sql_prefix}#{bin} "#{user}"/"#{password}"@#{host}:#{port}/#{@service}#{sql_postfix}}
-      elsif @su_user.nil?
-        %{#{sql_prefix}#{bin} "#{user}"/"#{password}"@#{host}:#{port}/#{@service} as #{@db_role}#{sql_postfix}}
-      else
-        %{su - #{@su_user} -c "env ORACLE_SID=#{@service} #{bin} / as #{@db_role}#{sql_postfix}}
-      end
-    end
-
-    def verify_query(query)
-      query += ";" unless query.strip.end_with?(";")
-      query
-    end
-
-    def parse_csv_result(stdout)
-      output = stdout.delete(/\r/)
-      table = CSV.parse(output, { headers: true })
-
-      # convert to hash
-      headers = table.headers
-
-      results = table.map do |row|
-        res = {}
-        headers.each do |header|
-          res[header.downcase] = row[header]
-        end
-        Hashie::Mash.new(res)
-      end
-      results
-    end
-
-    def parse_html_result(stdout)
-      result = stdout
-      # make oracle html valid html by removing the p tag, it does not include a closing tag
-      result = result.gsub("<p>", "").gsub("</p>", "").gsub("<br>", "")
-      doc = REXML::Document.new result
-      table = doc.elements["table"]
-      hash = []
-      unless table.nil?
-        rows = table.elements.to_a
-        headers = rows[0].elements.to_a("th").map { |entry| entry.text.strip }
-        rows.delete_at(0)
-
-        # iterate over each row, first row is header
-        hash = []
-        if !rows.nil? && !rows.empty?
-          hash = rows.map do |row|
-            res = {}
-            entries = row.elements.to_a("td")
-            # ignore if we have empty entries, oracle is adding th rows in between
-            return nil if entries.empty?
-
-            headers.each_with_index do |header, index|
-              # we need htmlentities since we do not have nokogiri
-              coder = HTMLEntities.new
-              val = coder.decode(entries[index].text).strip
-              res[header.downcase] = val
-            end
-            Hashie::Mash.new(res)
-          end.compact
-        end
-      end
-      hash
-    end
-  end
-end

data/lib/inspec/resources/os.rb

@@ -1,34 +0,0 @@
-require "inspec/resources/platform"
-
-module Inspec::Resources
-  class OSResource < PlatformResource
-    name "os"
-    supports platform: "unix"
-    supports platform: "windows"
-    desc "Use the os InSpec audit resource to test the platform on which the system is running."
-    example <<~EXAMPLE
-      describe os[:family] do
-        it { should eq 'redhat' }
-      end
-
-      describe os.redhat? do
-        it { should eq true }
-      end
-
-      describe os.linux? do
-        it { should eq true }
-      end
-    EXAMPLE
-
-    # reuse helper methods from backend
-    %w{aix? redhat? debian? suse? bsd? solaris? linux? unix? windows? hpux? darwin?}.each do |os_family|
-      define_method(os_family.to_sym) do
-        @platform.send(os_family)
-      end
-    end
-
-    def to_s
-      "Operating System Detection"
-    end
-  end
-end

data/lib/inspec/resources/os_env.rb

@@ -1,86 +0,0 @@
-# copyright: 2015, Vulcano Security GmbH
-
-# Usage:
-#
-# describe os_env('PATH') do
-#   its('split') { should_not include('') }
-#   its('split') { should_not include('.') }
-# end
-
-require "inspec/utils/simpleconfig"
-
-module Inspec::Resources
-  class OsEnv < Inspec.resource(1)
-    name "os_env"
-    supports platform: "unix"
-    supports platform: "windows"
-    desc "Use the os_env InSpec audit resource to test the environment variables for the platform on which the system is running."
-    example <<~EXAMPLE
-      describe os_env('VARIABLE') do
-        its('matcher') { should eq 1 }
-      end
-    EXAMPLE
-
-    def initialize(env = nil, target = nil)
-      @osenv = env
-      @target = unless target.nil?
-                  if target.casecmp("system") == 0
-                    "Machine"
-                  else
-                    "User"
-                  end
-                end
-    end
-
-    def split
-      # we can't take advantage of `File::PATH_SEPARATOR` as code is
-      # evaluated on the host machine
-      path_separator = inspec.os.windows? ? ";" : ":"
-      # -1 is required to catch cases like dir1::dir2:
-      # where we have a trailing :
-      content.nil? ? [] : content.split(path_separator, -1)
-    end
-
-    def content
-      return @content if defined?(@content)
-
-      @content = value_for(@osenv, @target) unless @osenv.nil?
-    end
-
-    def to_s
-      if @osenv.nil?
-        "Environment variables"
-      else
-        "Environment variable #{@osenv}"
-      end
-    end
-
-    private
-
-    def value_for(env, target = nil)
-      command = if inspec.os.windows?
-                  if target.nil?
-                    "${Env:#{env}}"
-                  else
-                    "[System.Environment]::GetEnvironmentVariable('#{env}', [System.EnvironmentVariableTarget]::#{target})"
-                  end
-                else
-                  "env"
-                end
-
-      out = inspec.command(command)
-
-      unless out.exit_status == 0
-        skip_resource "Can't read environment variables on #{inspec.os.name}. "\
-          "Tried `#{command}` which returned #{out.exit_status}"
-      end
-
-      if inspec.os.windows?
-        out.stdout.strip
-      else
-        params = SimpleConfig.new(out.stdout).params
-        params[env]
-      end
-    end
-  end
-end

data/lib/inspec/resources/package.rb

@@ -1,391 +0,0 @@
-require "inspec/resources/directory"
-require "inspec/utils/simpleconfig"
-
-# Resource to determine package information
-#
-# Usage:
-# describe package('nginx') do
-#   it { should be_installed }
-# end
-module Inspec::Resources
-  class Package < Inspec.resource(1)
-    name "package"
-    supports platform: "unix"
-    supports platform: "windows"
-    desc "Use the package InSpec audit resource to test if the named package and/or package version is installed on the system."
-    example <<~EXAMPLE
-      describe package('nginx') do
-        it { should be_installed }
-        it { should_not be_held } # for dpkg platforms that support holding a version from being upgraded
-        its('version') { should eq 1.9.5 }
-      end
-    EXAMPLE
-    def initialize(package_name, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      @package_name = package_name
-      @name = @package_name
-      @cache = nil
-      # select package manager
-      @pkgman = nil
-
-      os = inspec.os
-      if os.debian?
-        @pkgman = Deb.new(inspec)
-      elsif os.redhat? || %w{suse amazon fedora}.include?(os[:family])
-        @pkgman = Rpm.new(inspec, opts)
-      elsif ["arch"].include?(os[:name])
-        @pkgman = Pacman.new(inspec)
-      elsif ["darwin"].include?(os[:family])
-        @pkgman = Brew.new(inspec)
-      elsif os.windows?
-        @pkgman = WindowsPkg.new(inspec)
-      elsif ["aix"].include?(os[:family])
-        @pkgman = BffPkg.new(inspec)
-      elsif os.solaris?
-        @pkgman = SolarisPkg.new(inspec)
-      elsif ["hpux"].include?(os[:family])
-        @pkgman = HpuxPkg.new(inspec)
-      elsif ["alpine"].include?(os[:name])
-        @pkgman = AlpinePkg.new(inspec)
-      else
-        raise Inspec::Exceptions::ResourceSkipped, "The `package` resource is not supported on your OS yet."
-      end
-
-      evaluate_missing_requirements
-    end
-
-    # returns true if the package is installed
-    def installed?(_provider = nil, _version = nil)
-      info[:installed] == true
-    end
-
-    # returns true it the package is held (if the OS supports it)
-    def held?(_provider = nil, _version = nil)
-      info[:held] == true
-    end
-
-    # returns the package description
-    def info
-      return @cache unless @cache.nil?
-      # All `@pkgman.info` methods return `{}`. This matches that
-      # behavior if `@pkgman` can't be determined, thus avoiding the
-      # `undefined method 'info' for nil:NilClass` error
-      return {} if @pkgman.nil?
-
-      @pkgman.info(@package_name)
-    end
-
-    # return the package version
-    def version
-      info = @pkgman.info(@package_name)
-      info[:version]
-    end
-
-    def to_s
-      "System Package #{@package_name}"
-    end
-
-    private
-
-    def evaluate_missing_requirements
-      missing_requirements_string = @pkgman.missing_requirements.uniq.join(", ")
-      return if missing_requirements_string.empty?
-
-      raise Inspec::Exceptions::ResourceSkipped, "The following requirements are not met for this resource: #{missing_requirements_string}"
-    end
-  end
-
-  class PkgManagement
-    attr_reader :inspec
-    def initialize(inspec)
-      @inspec = inspec
-    end
-
-    def missing_requirements
-      # Each provider can provide an Array of missing requirements that will be
-      # combined into a `ResourceSkipped` exception message.
-      []
-    end
-  end
-
-  # Debian / Ubuntu
-  class Deb < PkgManagement
-    def info(package_name)
-      cmd = inspec.command("dpkg -s #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      params = SimpleConfig.new(
-        cmd.stdout.chomp,
-        assignment_regex: /^\s*([^:]*?)\s*:\s*(.*?)\s*$/,
-        multiple_values: false
-      ).params
-      # If the package is installed, Status is "install ok installed"
-      # If the package is installed and marked hold, Status is "hold ok installed"
-      # If the package is removed and not purged, Status is "deinstall ok config-files" with exit_status 0
-      # If the package is purged cmd fails with non-zero exit status
-      {
-        name: params["Package"],
-        installed: params["Status"].split(" ")[2] == "installed",
-        held: params["Status"].split(" ")[0] == "hold",
-        version: params["Version"],
-        type: "deb",
-      }
-    end
-  end
-
-  # RHEL family
-  class Rpm < PkgManagement
-    def initialize(inspec, opts)
-      super(inspec)
-
-      @dbpath = opts.fetch(:rpm_dbpath, nil)
-    end
-
-    def missing_requirements
-      missing_requirements = []
-
-      unless @dbpath.nil? || inspec.directory(@dbpath).directory?
-        missing_requirements << "RPMDB #{@dbpath} does not exist"
-      end
-
-      missing_requirements
-    end
-
-    def info(package_name)
-      rpm_cmd = rpm_command(package_name)
-      cmd = inspec.command(rpm_cmd)
-      # CentOS does not return an error code if the package is not installed,
-      # therefore we need to check for emptyness
-      return {} if cmd.exit_status.to_i != 0 || cmd.stdout.chomp.empty?
-
-      params = SimpleConfig.new(
-        cmd.stdout.chomp,
-        assignment_regex: /^\s*([^:]*?)\s*:\s*(.*?)\s*$/,
-        multiple_values: false
-      ).params
-      # On some (all?) systems, the linebreak before the vendor line is missing
-      if params["Version"] =~ /\s*Vendor:/
-        v = params["Version"].split(" ")[0]
-      else
-        v = params["Version"]
-      end
-      # On some (all?) systems, the linebreak before the build line is missing
-      if params["Release"] =~ /\s*Build Date:/
-        r = params["Release"].split(" ")[0]
-      else
-        r = params["Release"]
-      end
-      {
-        name: params["Name"],
-        installed: true,
-        version: "#{v}-#{r}",
-        type: "rpm",
-      }
-    end
-
-    private
-
-    def rpm_command(package_name)
-      cmd = ""
-      cmd += "rpm -qi"
-      cmd += " --dbpath #{@dbpath}" if @dbpath
-      cmd += " " + package_name
-
-      cmd
-    end
-  end
-
-  # MacOS / Darwin implementation
-  class Brew < PkgManagement
-    def info(package_name)
-      brew_path = inspec.command("brew").exist? ? "brew" : "/usr/local/bin/brew"
-      cmd = inspec.command("#{brew_path} info --json=v1 #{package_name}")
-
-      # If no available formula exists, then `brew` will exit non-zero
-      return {} if cmd.exit_status.to_i != 0
-
-      pkg = JSON.parse(cmd.stdout)[0]
-
-      # If package exists but is not installed, then `brew` output will not
-      # contain `pkg['installed'][0]['version']
-      return {} unless pkg.dig("installed", 0, "version")
-
-      {
-        name: pkg["name"],
-        installed: true,
-        version: pkg["installed"][0]["version"],
-        type: "brew",
-      }
-    rescue JSON::ParserError => e
-      raise Inspec::Exceptions::ResourceFailed,
-            "Failed to parse JSON from `brew` command. Error: #{e}"
-    end
-  end
-
-  # Arch Linux
-  class Pacman < PkgManagement
-    def info(package_name)
-      cmd = inspec.command("pacman -Qi #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      params = SimpleConfig.new(
-        cmd.stdout.chomp,
-        assignment_regex: /^\s*([^:]*?)\s*:\s*(.*?)\s*$/,
-        multiple_values: false
-      ).params
-
-      {
-        name: params["Name"],
-        installed: true,
-        version: params["Version"],
-        type: "pacman",
-      }
-    end
-  end
-
-  class HpuxPkg < PkgManagement
-    def info(package_name)
-      cmd = inspec.command("swlist -l product | grep #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      pkg = cmd.stdout.strip.split(" ")
-      {
-        name: pkg[0],
-        installed: true,
-        version: pkg[1],
-        type: "pkg",
-      }
-    end
-  end
-
-  class AlpinePkg < PkgManagement
-    def info(package_name)
-      cmd = inspec.command("apk info -vv --no-network | grep #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      pkg_info = cmd.stdout.split("\n").delete_if { |e| e =~ /^WARNING/i }
-      pkg = pkg_info[0].split(" - ")[0]
-
-      {
-        name: pkg.partition("-")[0],
-        installed: true,
-        version: pkg.partition("-")[2],
-        type: "pkg",
-      }
-    end
-  end
-
-  # Determines the installed packages on Windows using the Windows package registry entries.
-  # @see: http://blogs.technet.com/b/heyscriptingguy/archive/2013/11/15/use-powershell-to-find-installed-software.aspx
-  class WindowsPkg < PkgManagement
-    def info(package_name)
-      search_paths = [
-        'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
-        'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
-      ]
-
-      # add 64 bit search paths
-      if inspec.os.arch == "x86_64"
-        search_paths << 'HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'
-        search_paths << 'HKCU:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'
-      end
-
-      # Find the package
-      cmd = inspec.command <<-EOF.gsub(/^\s*/, "")
-        Get-ItemProperty (@("#{search_paths.join('", "')}") | Where-Object { Test-Path $_ }) |
-        Where-Object { $_.DisplayName -match "^\s*#{package_name.shellescape}\.*" -or $_.PSChildName -match "^\s*#{package_name.shellescape}\.*" } |
-        Select-Object -Property DisplayName,DisplayVersion | ConvertTo-Json
-      EOF
-
-      # We cannot rely on `exit_status` since PowerShell always exits 0 from the
-      # above command. Instead, if no package is found the output of the command
-      # will be `''` so we can use that to return `{}` to match the behavior of
-      # other package managers.
-      return {} if cmd.stdout == ""
-
-      begin
-        package = JSON.parse(cmd.stdout)
-      rescue JSON::ParserError => e
-        raise Inspec::Exceptions::ResourceFailed,
-              "Failed to parse JSON from PowerShell. Error: #{e}"
-      end
-
-      # What if we match multiple packages?  just pick the first one for now.
-      package = package[0] if package.is_a?(Array)
-
-      {
-        name: package["DisplayName"],
-        installed: true,
-        version: package["DisplayVersion"],
-        type: "windows",
-      }
-    end
-  end
-
-  # AIX
-  class BffPkg < PkgManagement
-    def info(package_name)
-      cmd = inspec.command("lslpp -cL #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      bff_pkg = cmd.stdout.split("\n").last.split(":")
-      {
-        name: bff_pkg[1],
-        installed: true,
-        version: bff_pkg[2],
-        type: "bff",
-      }
-    end
-  end
-
-  # Solaris
-  class SolarisPkg < PkgManagement
-    def info(package_name)
-      if inspec.os[:release].to_i <= 10
-        solaris10_info(package_name)
-      else
-        solaris11_info(package_name)
-      end
-    end
-
-    # solaris 10
-    def solaris10_info(package_name)
-      cmd = inspec.command("pkginfo -l #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      params = SimpleConfig.new(
-        cmd.stdout.chomp,
-        assignment_regex: /^\s*([^:]*?)\s*:\s*(.*?)\s*$/,
-        multiple_values: false
-      ).params
-
-      # parse 11.10.0,REV=2006.05.18.01.46
-      v = params["VERSION"].split(",")
-      {
-        name: params["PKGINST"],
-        installed: true,
-        version: v[0] + "-" + v[1].split("=")[1],
-        type: "pkg",
-      }
-    end
-
-    # solaris 11
-    def solaris11_info(package_name)
-      cmd = inspec.command("pkg info #{package_name}")
-      return {} if cmd.exit_status.to_i != 0
-
-      params = SimpleConfig.new(
-        cmd.stdout.chomp,
-        assignment_regex: /^\s*([^:]*?)\s*:\s*(.*?)\s*$/,
-        multiple_values: false
-      ).params
-
-      {
-        name: params["Name"],
-        installed: true,
-        # 0.5.11-0.175.3.1.0.5.0
-        version: "#{params["Version"]}-#{params["Branch"]}",
-        type: "pkg",
-      }
-    end
-  end
-end