inspec 2.1.0 → 2.1.10

data/lib/inspec/dependencies/cache.rb

@@ -1,72 +1,72 @@
-# encoding: utf-8
-require 'fileutils'
-
-module Inspec
-  #
-  # Inspec::Cache manages an on-disk cache of inspec profiles.  The
-  # cache can contain:
-  #
-  #  - .tar.gz profile archives
-  #  - .zip profile archives
-  #  - unpacked profiles
-  #
-  # Cache entries names include a hash of their source to prevent
-  # conflicts between depenedencies with the same name from different
-  # sources.
-  #
-  #
-  class Cache
-    attr_reader :path
-    def initialize(path = nil)
-      @path = path || File.join(Dir.home, '.inspec', 'cache')
-      FileUtils.mkdir_p(@path) unless File.directory?(@path)
-    end
-
-    def prefered_entry_for(key)
-      path = base_path_for(key)
-      if File.directory?(path)
-        path
-      else
-        archive_entry_for(key)
-      end
-    end
-
-    def archive_entry_for(key)
-      path = base_path_for(key)
-      if File.exist?("#{path}.tar.gz")
-        "#{path}.tar.gz"
-      elsif File.exist?("#{path}.zip")
-        "#{path}.zip"
-      end
-    end
-
-    #
-    # For a given name and source_url, return true if the
-    # profile exists in the Cache.
-    #
-    # @param [String] name
-    # @param [String] source_url
-    # @return [Boolean]
-    #
-    def exists?(key)
-      return false if key.nil? || key.empty?
-      path = base_path_for(key)
-      File.directory?(path) || File.exist?("#{path}.tar.gz") || File.exist?("#{path}.zip")
-    end
-
-    #
-    # Return the path to given profile in the cache.
-    #
-    # The `source_url` parameter should be a URI-like string that
-    # fully specifies the source of the exact version we want to pull
-    # down.
-    #
-    # @param [String] name
-    # @param [String] source_url
-    # @return [String]
-    #
-    def base_path_for(cache_key)
-      File.join(@path, cache_key)
-    end
-  end
-end
+# encoding: utf-8
+require 'fileutils'
+
+module Inspec
+  #
+  # Inspec::Cache manages an on-disk cache of inspec profiles.  The
+  # cache can contain:
+  #
+  #  - .tar.gz profile archives
+  #  - .zip profile archives
+  #  - unpacked profiles
+  #
+  # Cache entries names include a hash of their source to prevent
+  # conflicts between depenedencies with the same name from different
+  # sources.
+  #
+  #
+  class Cache
+    attr_reader :path
+    def initialize(path = nil)
+      @path = path || File.join(Dir.home, '.inspec', 'cache')
+      FileUtils.mkdir_p(@path) unless File.directory?(@path)
+    end
+
+    def prefered_entry_for(key)
+      path = base_path_for(key)
+      if File.directory?(path)
+        path
+      else
+        archive_entry_for(key)
+      end
+    end
+
+    def archive_entry_for(key)
+      path = base_path_for(key)
+      if File.exist?("#{path}.tar.gz")
+        "#{path}.tar.gz"
+      elsif File.exist?("#{path}.zip")
+        "#{path}.zip"
+      end
+    end
+
+    #
+    # For a given name and source_url, return true if the
+    # profile exists in the Cache.
+    #
+    # @param [String] name
+    # @param [String] source_url
+    # @return [Boolean]
+    #
+    def exists?(key)
+      return false if key.nil? || key.empty?
+      path = base_path_for(key)
+      File.directory?(path) || File.exist?("#{path}.tar.gz") || File.exist?("#{path}.zip")
+    end
+
+    #
+    # Return the path to given profile in the cache.
+    #
+    # The `source_url` parameter should be a URI-like string that
+    # fully specifies the source of the exact version we want to pull
+    # down.
+    #
+    # @param [String] name
+    # @param [String] source_url
+    # @return [String]
+    #
+    def base_path_for(cache_key)
+      File.join(@path, cache_key)
+    end
+  end
+end

data/lib/inspec/dependencies/dependency_set.rb

@@ -1,92 +1,92 @@
-# encoding: utf-8
-require 'inspec/dependencies/requirement'
-require 'inspec/dependencies/resolver'
-
-module Inspec
-  #
-  # A DependencySet manages a list of dependencies for a profile.
-  #
-  class DependencySet
-    #
-    # Return a dependency set given a lockfile.
-    #
-    # @param lockfile [Inspec::Lockfile] A lockfile to generate the dependency set from
-    # @param cwd [String] Current working directory for relative path includes
-    # @param vendor_path [String] Path to the vendor directory
-    #
-    def self.from_lockfile(lockfile, cwd, cache, backend, opts = {})
-      dep_tree = lockfile.deps.map do |dep|
-        Inspec::Requirement.from_lock_entry(dep, cwd, cache, backend, opts)
-      end
-
-      dep_list = flatten_dep_tree(dep_tree)
-      new(cwd, cache, dep_list, backend)
-    end
-
-    def self.from_array(dependencies, cwd, cache, backend)
-      dep_list = {}
-      dependencies.each do |d|
-        dep_list[d.name] = d
-      end
-      new(cwd, cache, dep_list, backend)
-    end
-
-    # This is experimental code to test the working of the
-    # dependency loader - perform a proper dependency related search
-    # in the future.
-    #
-    # Flatten tree because that is all we know how to deal with for
-    # right now. Last dep seen for a given name wins right now.
-    def self.flatten_dep_tree(dep_tree)
-      dep_list = {}
-      dep_tree.each do |d|
-        dep_list[d.name] = d
-        dep_list.merge!(flatten_dep_tree(d.dependencies))
-      end
-      dep_list
-    end
-
-    attr_reader :vendor_path
-    attr_writer :dep_list
-    # initialize
-    #
-    # @param cwd [String] current working directory for relative path includes
-    # @param vendor_path [String] path which contains vendored dependencies
-    # @return [dependencies] this
-    def initialize(cwd, cache, dep_list, backend)
-      @cwd = cwd
-      @cache = cache
-      @dep_list = dep_list
-      @backend = backend
-    end
-
-    def each
-      @dep_list.each do |_k, v|
-        yield v.profile
-      end
-    end
-
-    def list
-      @dep_list || {}
-    end
-
-    def to_array
-      return [] if @dep_list.nil?
-      @dep_list.map do |_k, v|
-        v.to_hash
-      end.compact
-    end
-
-    #
-    # 1. Get dependencies, pull things to a local cache if necessary
-    # 2. Resolve dependencies
-    #
-    # @param dependencies [Gem::Dependency] list of dependencies
-    # @return [nil]
-    #
-    def vendor(dependencies)
-      return nil if dependencies.nil? || dependencies.empty?
-      @dep_list = Resolver.resolve(dependencies, @cache, @cwd, @backend)
-    end
-  end
-end
+# encoding: utf-8
+require 'inspec/dependencies/requirement'
+require 'inspec/dependencies/resolver'
+
+module Inspec
+  #
+  # A DependencySet manages a list of dependencies for a profile.
+  #
+  class DependencySet
+    #
+    # Return a dependency set given a lockfile.
+    #
+    # @param lockfile [Inspec::Lockfile] A lockfile to generate the dependency set from
+    # @param cwd [String] Current working directory for relative path includes
+    # @param vendor_path [String] Path to the vendor directory
+    #
+    def self.from_lockfile(lockfile, cwd, cache, backend, opts = {})
+      dep_tree = lockfile.deps.map do |dep|
+        Inspec::Requirement.from_lock_entry(dep, cwd, cache, backend, opts)
+      end
+
+      dep_list = flatten_dep_tree(dep_tree)
+      new(cwd, cache, dep_list, backend)
+    end
+
+    def self.from_array(dependencies, cwd, cache, backend)
+      dep_list = {}
+      dependencies.each do |d|
+        dep_list[d.name] = d
+      end
+      new(cwd, cache, dep_list, backend)
+    end
+
+    # This is experimental code to test the working of the
+    # dependency loader - perform a proper dependency related search
+    # in the future.
+    #
+    # Flatten tree because that is all we know how to deal with for
+    # right now. Last dep seen for a given name wins right now.
+    def self.flatten_dep_tree(dep_tree)
+      dep_list = {}
+      dep_tree.each do |d|
+        dep_list[d.name] = d
+        dep_list.merge!(flatten_dep_tree(d.dependencies))
+      end
+      dep_list
+    end
+
+    attr_reader :vendor_path
+    attr_writer :dep_list
+    # initialize
+    #
+    # @param cwd [String] current working directory for relative path includes
+    # @param vendor_path [String] path which contains vendored dependencies
+    # @return [dependencies] this
+    def initialize(cwd, cache, dep_list, backend)
+      @cwd = cwd
+      @cache = cache
+      @dep_list = dep_list
+      @backend = backend
+    end
+
+    def each
+      @dep_list.each do |_k, v|
+        yield v.profile
+      end
+    end
+
+    def list
+      @dep_list || {}
+    end
+
+    def to_array
+      return [] if @dep_list.nil?
+      @dep_list.map do |_k, v|
+        v.to_hash
+      end.compact
+    end
+
+    #
+    # 1. Get dependencies, pull things to a local cache if necessary
+    # 2. Resolve dependencies
+    #
+    # @param dependencies [Gem::Dependency] list of dependencies
+    # @return [nil]
+    #
+    def vendor(dependencies)
+      return nil if dependencies.nil? || dependencies.empty?
+      @dep_list = Resolver.resolve(dependencies, @cache, @cwd, @backend)
+    end
+  end
+end

data/lib/inspec/dependencies/lockfile.rb

@@ -1,115 +1,115 @@
-# encoding: utf-8
-require 'yaml'
-
-module Inspec
-  class Lockfile
-    # When we finalize this feature, we should set these to 1
-    MINIMUM_SUPPORTED_VERSION = 1
-    CURRENT_LOCKFILE_VERSION = 1
-
-    def self.from_dependency_set(dep_set)
-      lockfile_content = {
-        'lockfile_version' => CURRENT_LOCKFILE_VERSION,
-        'depends' => dep_set.to_array,
-      }
-      new(lockfile_content)
-    end
-
-    def self.from_content(content)
-      parsed_content = YAML.load(content)
-      version = parsed_content['lockfile_version']
-      raise "No lockfile_version set in #{path}!" if version.nil?
-      validate_lockfile_version!(version.to_i)
-      new(parsed_content)
-    end
-
-    def self.from_file(path)
-      content = File.read(path)
-      from_content(content)
-    end
-
-    def self.validate_lockfile_version!(version)
-      if version < MINIMUM_SUPPORTED_VERSION
-        raise <<~EOF
-          This lockfile specifies a lockfile_version of #{version} which is
-          lower than the minimum supported version #{MINIMUM_SUPPORTED_VERSION}.
-
-          Please create a new lockfile for this project by running:
-
-              inspec vendor
-        EOF
-      elsif version > CURRENT_LOCKFILE_VERSION
-        raise <<~EOF
-          This lockfile claims to be version #{version} which is greater than
-          the most recent lockfile version(#{CURRENT_LOCKFILE_VERSION}).
-
-          This may happen if you are using an older version of inspec than was
-          used to create the lockfile.
-        EOF
-      end
-    end
-
-    attr_reader :version, :deps
-    def initialize(lockfile_content_hash)
-      version = lockfile_content_hash['lockfile_version']
-      @version = version.to_i
-      parse_content_hash(lockfile_content_hash)
-    end
-
-    def to_yaml
-      {
-        'lockfile_version' => CURRENT_LOCKFILE_VERSION,
-        'depends' => @deps.map { |i| stringify_keys(i) },
-      }.to_yaml
-    end
-
-    private
-
-    # Refactor this to be "version-wise" - i.e. make one dispatch
-    # function for each version so that even if it duplicates code,
-    # it can describe the part of the code that it expects to be
-    # different. Then that dispatch routine can call more well
-    # defined methods like "parse_v0_dependencies" or
-    # "parse_flat_dependencies" or what not as things generally
-    # develop. It does help people easily set breakpoints/track
-    # different entry points of the API.
-    def parse_content_hash(lockfile_content_hash)
-      case version
-      when 1
-        parse_content_hash_1(lockfile_content_hash)
-      else
-        # If we've gotten here, there is likely a mistake in the
-        # lockfile version validation in the constructor.
-        raise "No lockfile parser for version #{version}"
-      end
-    end
-
-    def parse_content_hash_1(lockfile_content_hash)
-      @deps = lockfile_content_hash['depends']&.map { |i| symbolize_keys(i) }
-    end
-
-    def mutate_hash_keys_with(hash, fun)
-      hash.each_with_object({}) do |v, memo|
-        key = fun.call(v[0])
-        value = if v[1].is_a?(Hash)
-                  mutate_hash_keys_with(v[1], fun)
-                elsif v[1].is_a?(Array)
-                  v[1].map do |i|
-                    i.is_a?(Hash) ? mutate_hash_keys_with(i, fun) : i
-                  end
-                else
-                  v[1]
-                end
-        memo[key] = value
-      end
-    end
-
-    def stringify_keys(hash)
-      mutate_hash_keys_with(hash, proc { |i| i.to_s })
-    end
-
-    def symbolize_keys(hash)
-      mutate_hash_keys_with(hash, proc { |i| i.to_sym })
-    end
-  end
-end
+# encoding: utf-8
+require 'yaml'
+
+module Inspec
+  class Lockfile
+    # When we finalize this feature, we should set these to 1
+    MINIMUM_SUPPORTED_VERSION = 1
+    CURRENT_LOCKFILE_VERSION = 1
+
+    def self.from_dependency_set(dep_set)
+      lockfile_content = {
+        'lockfile_version' => CURRENT_LOCKFILE_VERSION,
+        'depends' => dep_set.to_array,
+      }
+      new(lockfile_content)
+    end
+
+    def self.from_content(content)
+      parsed_content = YAML.load(content)
+      version = parsed_content['lockfile_version']
+      raise "No lockfile_version set in #{path}!" if version.nil?
+      validate_lockfile_version!(version.to_i)
+      new(parsed_content)
+    end
+
+    def self.from_file(path)
+      content = File.read(path)
+      from_content(content)
+    end
+
+    def self.validate_lockfile_version!(version)
+      if version < MINIMUM_SUPPORTED_VERSION
+        raise <<~EOF
+          This lockfile specifies a lockfile_version of #{version} which is
+          lower than the minimum supported version #{MINIMUM_SUPPORTED_VERSION}.
+
+          Please create a new lockfile for this project by running:
+
+              inspec vendor
+        EOF
+      elsif version > CURRENT_LOCKFILE_VERSION
+        raise <<~EOF
+          This lockfile claims to be version #{version} which is greater than
+          the most recent lockfile version(#{CURRENT_LOCKFILE_VERSION}).
+
+          This may happen if you are using an older version of inspec than was
+          used to create the lockfile.
+        EOF
+      end
+    end
+
+    attr_reader :version, :deps
+    def initialize(lockfile_content_hash)
+      version = lockfile_content_hash['lockfile_version']
+      @version = version.to_i
+      parse_content_hash(lockfile_content_hash)
+    end
+
+    def to_yaml
+      {
+        'lockfile_version' => CURRENT_LOCKFILE_VERSION,
+        'depends' => @deps.map { |i| stringify_keys(i) },
+      }.to_yaml
+    end
+
+    private
+
+    # Refactor this to be "version-wise" - i.e. make one dispatch
+    # function for each version so that even if it duplicates code,
+    # it can describe the part of the code that it expects to be
+    # different. Then that dispatch routine can call more well
+    # defined methods like "parse_v0_dependencies" or
+    # "parse_flat_dependencies" or what not as things generally
+    # develop. It does help people easily set breakpoints/track
+    # different entry points of the API.
+    def parse_content_hash(lockfile_content_hash)
+      case version
+      when 1
+        parse_content_hash_1(lockfile_content_hash)
+      else
+        # If we've gotten here, there is likely a mistake in the
+        # lockfile version validation in the constructor.
+        raise "No lockfile parser for version #{version}"
+      end
+    end
+
+    def parse_content_hash_1(lockfile_content_hash)
+      @deps = lockfile_content_hash['depends']&.map { |i| symbolize_keys(i) }
+    end
+
+    def mutate_hash_keys_with(hash, fun)
+      hash.each_with_object({}) do |v, memo|
+        key = fun.call(v[0])
+        value = if v[1].is_a?(Hash)
+                  mutate_hash_keys_with(v[1], fun)
+                elsif v[1].is_a?(Array)
+                  v[1].map do |i|
+                    i.is_a?(Hash) ? mutate_hash_keys_with(i, fun) : i
+                  end
+                else
+                  v[1]
+                end
+        memo[key] = value
+      end
+    end
+
+    def stringify_keys(hash)
+      mutate_hash_keys_with(hash, proc { |i| i.to_s })
+    end
+
+    def symbolize_keys(hash)
+      mutate_hash_keys_with(hash, proc { |i| i.to_sym })
+    end
+  end
+end