inspec 1.51.6 → 1.51.15

data/lib/bundles/inspec-compliance/configuration.rb

@@ -1,103 +1,103 @@
-# encoding: utf-8
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-module Compliance
-  # stores configuration on local filesystem
-  class Configuration
-    def initialize
-      @config_path = File.join(Dir.home, '.inspec', 'compliance')
-      # ensure the directory is available
-      unless File.directory?(@config_path)
-        FileUtils.mkdir_p(@config_path)
-      end
-      # set config file path
-      @config_file = File.join(@config_path, '/config.json')
-      @config = {}
-
-      # load the data
-      get
-    end
-
-    # direct access to config
-    def [](key)
-      @config[key]
-    end
-
-    def []=(key, value)
-      @config[key] = value
-    end
-
-    def key?(key)
-      @config.key?(key)
-    end
-
-    def clean
-      @config = {}
-    end
-
-    # return the json data
-    def get
-      if File.exist?(@config_file)
-        file = File.read(@config_file)
-        @config = JSON.parse(file)
-      end
-      @config
-    end
-
-    # stores a hash to json
-    def store
-      File.open(@config_file, 'w') do |f|
-        f.chmod(0600)
-        f.write(@config.to_json)
-      end
-    end
-
-    # deletes data
-    def destroy
-      if File.exist?(@config_file)
-        File.delete(@config_file)
-      else
-        true
-      end
-    end
-
-    # return if the (stored) api version does not support a certain feature
-    def supported?(feature)
-      sup = version_with_support(feature)
-
-      # we do not know the version, therefore we do not know if its possible to use the feature
-      return if self['version'].nil? || self['version']['version'].nil?
-
-      if sup.is_a?(Array)
-        Gem::Version.new(self['version']['version']) >= sup[0] &&
-          Gem::Version.new(self['version']['version']) < sup[1]
-      else
-        Gem::Version.new(self['version']['version']) >= sup
-      end
-    end
-
-    # exit 1 if the version of compliance that we're working with doesn't support odic
-    def legacy_check!(feature)
-      return if supported?(feature)
-
-      puts "This feature (#{feature}) is not available for legacy installations."
-      puts 'Please upgrade to a recent version of Chef Compliance.'
-      exit 1
-    end
-
-    private
-
-    # for a feature, returns either:
-    #  - a version v0:                      v supports v0       iff v0 <= v
-    #  - an array [v0, v1] of two versions: v supports [v0, v1] iff v0 <= v < v1
-    def version_with_support(feature)
-      case feature.to_sym
-      when :oidc
-        Gem::Version.new('0.16.19')
-      else
-        Gem::Version.new('0.0.0')
-      end
-    end
-  end
-end
+# encoding: utf-8
+# author: Christoph Hartmann
+# author: Dominik Richter
+
+module Compliance
+  # stores configuration on local filesystem
+  class Configuration
+    def initialize
+      @config_path = File.join(Dir.home, '.inspec', 'compliance')
+      # ensure the directory is available
+      unless File.directory?(@config_path)
+        FileUtils.mkdir_p(@config_path)
+      end
+      # set config file path
+      @config_file = File.join(@config_path, '/config.json')
+      @config = {}
+
+      # load the data
+      get
+    end
+
+    # direct access to config
+    def [](key)
+      @config[key]
+    end
+
+    def []=(key, value)
+      @config[key] = value
+    end
+
+    def key?(key)
+      @config.key?(key)
+    end
+
+    def clean
+      @config = {}
+    end
+
+    # return the json data
+    def get
+      if File.exist?(@config_file)
+        file = File.read(@config_file)
+        @config = JSON.parse(file)
+      end
+      @config
+    end
+
+    # stores a hash to json
+    def store
+      File.open(@config_file, 'w') do |f|
+        f.chmod(0600)
+        f.write(@config.to_json)
+      end
+    end
+
+    # deletes data
+    def destroy
+      if File.exist?(@config_file)
+        File.delete(@config_file)
+      else
+        true
+      end
+    end
+
+    # return if the (stored) api version does not support a certain feature
+    def supported?(feature)
+      sup = version_with_support(feature)
+
+      # we do not know the version, therefore we do not know if its possible to use the feature
+      return if self['version'].nil? || self['version']['version'].nil?
+
+      if sup.is_a?(Array)
+        Gem::Version.new(self['version']['version']) >= sup[0] &&
+          Gem::Version.new(self['version']['version']) < sup[1]
+      else
+        Gem::Version.new(self['version']['version']) >= sup
+      end
+    end
+
+    # exit 1 if the version of compliance that we're working with doesn't support odic
+    def legacy_check!(feature)
+      return if supported?(feature)
+
+      puts "This feature (#{feature}) is not available for legacy installations."
+      puts 'Please upgrade to a recent version of Chef Compliance.'
+      exit 1
+    end
+
+    private
+
+    # for a feature, returns either:
+    #  - a version v0:                      v supports v0       iff v0 <= v
+    #  - an array [v0, v1] of two versions: v supports [v0, v1] iff v0 <= v < v1
+    def version_with_support(feature)
+      case feature.to_sym
+      when :oidc
+        Gem::Version.new('0.16.19')
+      else
+        Gem::Version.new('0.0.0')
+      end
+    end
+  end
+end

data/lib/bundles/inspec-compliance/http.rb

@@ -1,86 +1,86 @@
-# encoding: utf-8
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-require 'net/http'
-require 'uri'
-
-module Compliance
-  # implements a simple http abstraction on top of Net::HTTP
-  class HTTP
-    # generic get requires
-    def self.get(url, headers = nil, insecure)
-      uri = _parse_url(url)
-      req = Net::HTTP::Get.new(uri.path)
-      headers&.each do |key, value|
-        req.add_field(key, value)
-      end
-      send_request(uri, req, insecure)
-    end
-
-    # generic post request
-    def self.post(url, token, insecure, basic_auth = false)
-      # form request
-      uri = _parse_url(url)
-      req = Net::HTTP::Post.new(uri.path)
-      if basic_auth
-        req.basic_auth token, ''
-      else
-        req['Authorization'] = "Bearer #{token}"
-      end
-      req.form_data={}
-
-      send_request(uri, req, insecure)
-    end
-
-    # post a file
-    def self.post_file(url, headers, file_path, insecure)
-      uri = _parse_url(url)
-      raise "Unable to parse URL: #{url}" if uri.nil? || uri.host.nil?
-      http = Net::HTTP.new(uri.host, uri.port)
-
-      # set connection flags
-      http.use_ssl = (uri.scheme == 'https')
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if insecure
-
-      req = Net::HTTP::Post.new(uri.path)
-      headers.each do |key, value|
-        req.add_field(key, value)
-      end
-
-      req.body_stream=File.open(file_path, 'rb')
-      req.add_field('Content-Length', File.size(file_path))
-      req.add_field('Content-Type', 'application/x-gtar')
-
-      boundary = 'INSPEC-PROFILE-UPLOAD'
-      req.add_field('session', boundary)
-      res=http.request(req)
-      res
-    end
-
-    # sends a http requests
-    def self.send_request(uri, req, insecure)
-      opts = {
-        use_ssl: uri.scheme == 'https',
-      }
-      opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE if insecure
-
-      raise "Unable to parse URI: #{uri}" if uri.nil? || uri.host.nil?
-      res = Net::HTTP.start(uri.host, uri.port, opts) { |http|
-        http.request(req)
-      }
-      res
-    rescue OpenSSL::SSL::SSLError => e
-      raise e unless e.message.include? 'certificate verify failed'
-
-      puts "Error: Failed to connect to #{uri}."
-      puts 'If the server uses a self-signed certificate, please re-run the login command with the --insecure option.'
-      exit 1
-    end
-
-    def self._parse_url(url)
-      url = "https://#{url}" if URI.parse(url).scheme.nil?
-      URI.parse(url)
-    end
-  end
-end
+# encoding: utf-8
+# author: Christoph Hartmann
+# author: Dominik Richter
+
+require 'net/http'
+require 'uri'
+
+module Compliance
+  # implements a simple http abstraction on top of Net::HTTP
+  class HTTP
+    # generic get requires
+    def self.get(url, headers = nil, insecure)
+      uri = _parse_url(url)
+      req = Net::HTTP::Get.new(uri.path)
+      headers&.each do |key, value|
+        req.add_field(key, value)
+      end
+      send_request(uri, req, insecure)
+    end
+
+    # generic post request
+    def self.post(url, token, insecure, basic_auth = false)
+      # form request
+      uri = _parse_url(url)
+      req = Net::HTTP::Post.new(uri.path)
+      if basic_auth
+        req.basic_auth token, ''
+      else
+        req['Authorization'] = "Bearer #{token}"
+      end
+      req.form_data={}
+
+      send_request(uri, req, insecure)
+    end
+
+    # post a file
+    def self.post_file(url, headers, file_path, insecure)
+      uri = _parse_url(url)
+      raise "Unable to parse URL: #{url}" if uri.nil? || uri.host.nil?
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      # set connection flags
+      http.use_ssl = (uri.scheme == 'https')
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if insecure
+
+      req = Net::HTTP::Post.new(uri.path)
+      headers.each do |key, value|
+        req.add_field(key, value)
+      end
+
+      req.body_stream=File.open(file_path, 'rb')
+      req.add_field('Content-Length', File.size(file_path))
+      req.add_field('Content-Type', 'application/x-gtar')
+
+      boundary = 'INSPEC-PROFILE-UPLOAD'
+      req.add_field('session', boundary)
+      res=http.request(req)
+      res
+    end
+
+    # sends a http requests
+    def self.send_request(uri, req, insecure)
+      opts = {
+        use_ssl: uri.scheme == 'https',
+      }
+      opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE if insecure
+
+      raise "Unable to parse URI: #{uri}" if uri.nil? || uri.host.nil?
+      res = Net::HTTP.start(uri.host, uri.port, opts) { |http|
+        http.request(req)
+      }
+      res
+    rescue OpenSSL::SSL::SSLError => e
+      raise e unless e.message.include? 'certificate verify failed'
+
+      puts "Error: Failed to connect to #{uri}."
+      puts 'If the server uses a self-signed certificate, please re-run the login command with the --insecure option.'
+      exit 1
+    end
+
+    def self._parse_url(url)
+      url = "https://#{url}" if URI.parse(url).scheme.nil?
+      URI.parse(url)
+    end
+  end
+end

data/lib/bundles/inspec-compliance/support.rb

@@ -1,36 +1,36 @@
-# encoding: utf-8
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-module Compliance
-  # is a helper that provides information which version of compliance supports
-  # which feature
-  class Support
-    # for a feature, returns either:
-    #  - a version v0:                      v supports v0       iff v0 <= v
-    #  - an array [v0, v1] of two versions: v supports [v0, v1] iff v0 <= v < v1
-    def self.version_with_support(feature)
-      case feature.to_sym
-      when :oidc # open id connect authentication
-        Gem::Version.new('0.16.19')
-      else
-        Gem::Version.new('0.0.0')
-      end
-    end
-
-    # determines if the given version support a certain feature
-    def self.supported?(feature, version)
-      sup = version_with_support(feature)
-
-      if sup.is_a?(Array)
-        Gem::Version.new(version) >= sup[0] &&
-          Gem::Version.new(version) < sup[1]
-      else
-        Gem::Version.new(version) >= sup
-      end
-    end
-
-    # we do not know the version, therefore we do not know if its possible to use the feature
-    # return if self['version'].nil? || self['version']['version'].nil?
-  end
-end
+# encoding: utf-8
+# author: Christoph Hartmann
+# author: Dominik Richter
+
+module Compliance
+  # is a helper that provides information which version of compliance supports
+  # which feature
+  class Support
+    # for a feature, returns either:
+    #  - a version v0:                      v supports v0       iff v0 <= v
+    #  - an array [v0, v1] of two versions: v supports [v0, v1] iff v0 <= v < v1
+    def self.version_with_support(feature)
+      case feature.to_sym
+      when :oidc # open id connect authentication
+        Gem::Version.new('0.16.19')
+      else
+        Gem::Version.new('0.0.0')
+      end
+    end
+
+    # determines if the given version support a certain feature
+    def self.supported?(feature, version)
+      sup = version_with_support(feature)
+
+      if sup.is_a?(Array)
+        Gem::Version.new(version) >= sup[0] &&
+          Gem::Version.new(version) < sup[1]
+      else
+        Gem::Version.new(version) >= sup
+      end
+    end
+
+    # we do not know the version, therefore we do not know if its possible to use the feature
+    # return if self['version'].nil? || self['version']['version'].nil?
+  end
+end