berkshelf 5.2.0 → 8.0.15

data/lib/berkshelf/chef_config_compat.rb

@@ -0,0 +1,51 @@
+require "chef-config/config"
+require "chef-config/workstation_config_loader"
+require "socket" unless defined?(Socket) # FIXME: why?
+
+module Berkshelf
+  class ChefConfigCompat
+    # Create a new Chef Config object.
+    #
+    # @param [#to_s] path
+    #   the path to the configuration file
+    # @param [Hash] options
+    def initialize(path, options = {})
+      ChefConfig::WorkstationConfigLoader.new(path).load
+      ChefConfig::Config.merge!(options)
+      ChefConfig::Config.export_proxies # Set proxy settings as environment variables
+      ChefConfig::Config.init_openssl # setup openssl + fips mode
+    end
+
+    # Keep defaults that aren't in ChefConfig::Config
+    def cookbook_copyright(*args, &block)
+      ChefConfig::Config.cookbook_copyright(*args, &block) || "YOUR_NAME"
+    end
+
+    def cookbook_email(*args, &block)
+      ChefConfig::Config.cookbook_email(*args, &block) || "YOUR_EMAIL"
+    end
+
+    def cookbook_license(*args, &block)
+      ChefConfig::Config.cookbook_license(*args, &block) || "reserved"
+    end
+
+    # The configuration as a hash
+    def to_hash
+      ChefConfig::Config.save(true)
+    end
+
+    # Load from a file
+    def self.from_file(file)
+      new(file)
+    end
+
+    # Behave just like ChefConfig::Config in general
+    def method_missing(name, *args, &block)
+      ChefConfig::Config.send(name, *args, &block)
+    end
+
+    def respond_to_missing?(name)
+      ChefConfig::Config.respond_to?(name)
+    end
+  end
+end

data/lib/berkshelf/chef_repo_universe.rb

@@ -0,0 +1,47 @@
+require_relative "api_client/remote_cookbook"
+require_relative "cached_cookbook"
+
+module Berkshelf
+  # Shim to look like a Berkshelf::APIClient but for a chef repo folder.
+  #
+  # @since 6.1
+  class ChefRepoUniverse
+    def initialize(uri, **options)
+      @uri = uri
+      @path = options[:path]
+      @options = options
+    end
+
+    def universe
+      Dir.entries(cookbooks_path).sort.each_with_object([]) do |entry, cookbooks|
+        next if entry[0] == "." # Skip hidden folders.
+
+        entry_path = "#{cookbooks_path}/#{entry}"
+        next unless File.directory?(entry_path) # Skip non-dirs.
+
+        cookbook = begin
+          Berkshelf::CachedCookbook.from_path(entry_path)
+                   rescue IOError
+                     next # It wasn't a cookbook.
+        end
+        cookbooks << Berkshelf::APIClient::RemoteCookbook.new(
+          cookbook.cookbook_name,
+          cookbook.version,
+          location_type: "file_store",
+          location_path: entry_path,
+          dependencies: cookbook.metadata.dependencies
+        )
+      end
+    end
+
+    private
+
+    def cookbooks_path
+      if File.exist?("#{@path}/cookbooks")
+        "#{@path}/cookbooks"
+      else
+        @path
+      end
+    end
+  end
+end

data/lib/berkshelf/cli.rb

@@ -1,9 +1,6 @@
-require 'berkshelf'
-require_relative 'config'
-require_relative 'init_generator'
-require_relative 'cookbook_generator'
-require_relative 'commands/shelf'
-require_relative 'commands/test_command'
+require_relative "../berkshelf"
+require_relative "config"
+require_relative "commands/shelf"
 
 module Berkshelf
   class Cli < Thor
@@ -19,22 +16,20 @@ module Berkshelf
       end
 
       def execute!
-        begin
-          $stdin  = @stdin
-          $stdout = @stdout
-          $stderr = @stderr
-
-          Berkshelf::Cli.start(@argv)
-          @kernel.exit(0)
-        rescue Berkshelf::BerkshelfError => e
-          Berkshelf.ui.error e
-          Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV['BERKSHELF_DEBUG']
-          @kernel.exit(e.status_code)
-        rescue Ridley::Errors::RidleyError => e
-          Berkshelf.ui.error "#{e.class} #{e}"
-          Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV['BERKSHELF_DEBUG']
-          @kernel.exit(47)
-        end
+        $stdin  = @stdin
+        $stdout = @stdout
+        $stderr = @stderr
+
+        Berkshelf::Cli.start(@argv)
+        @kernel.exit(0)
+      rescue Berkshelf::BerkshelfError => e
+        Berkshelf.ui.error e
+        Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV["BERKSHELF_DEBUG"]
+        @kernel.exit(e.status_code)
+      rescue => e
+        Berkshelf.ui.error "#{e.class} #{e}"
+        Berkshelf.ui.error "\t" + e.backtrace.join("\n\t") if ENV["BERKSHELF_DEBUG"]
+        @kernel.exit(47)
       end
     end
 
@@ -43,14 +38,14 @@ module Berkshelf
         if given_args.length > 1 && !(given_args & Thor::HELP_MAPPINGS).empty?
           command = given_args.first
 
-          if self.subcommands.include?(command)
-            super(meth, [command, 'help'].compact, nil, config)
+          if subcommands.include?(command)
+            super(meth, [command, "help"].compact, nil, config)
           else
-            super(meth, ['help', command].compact, nil, config)
+            super(meth, ["help", command].compact, nil, config)
           end
         else
           super
-          Berkshelf.formatter.cleanup_hook unless config[:current_command].name == 'help'
+          Berkshelf.formatter.cleanup_hook unless config[:current_command].name == "help"
         end
       end
     end
@@ -79,66 +74,59 @@ module Berkshelf
       @options = options.dup # unfreeze frozen options Hash from Thor
     end
 
-    namespace 'berkshelf'
+    namespace "berkshelf"
 
-    map 'in'   => :install
-    map 'up'   => :upload
-    map 'ud'   => :update
-    map 'ls'   => :list
-    map 'book' => :cookbook
-    map ['ver', '-v', '--version'] => :version
+    map "in"   => :install
+    map "up"   => :upload
+    map "ud"   => :update
+    map "ls"   => :list
+    map "book" => :cookbook
+    map ["ver", "-v", "--version"] => :version
 
     default_task :install
 
     class_option :config,
       type: :string,
-      desc: 'Path to Berkshelf configuration to use.',
-      aliases: '-c',
-      banner: 'PATH'
+      desc: "Path to Berkshelf configuration to use.",
+      aliases: "-c",
+      banner: "PATH"
     class_option :format,
       type: :string,
-      default: 'human',
-      desc: 'Output format to use.',
-      aliases: '-F',
-      banner: 'FORMAT'
+      default: "human",
+      desc: "Output format to use.",
+      aliases: "-F",
+      banner: "FORMAT"
     class_option :quiet,
       type: :boolean,
-      desc: 'Silence all informational output.',
-      aliases: '-q',
+      desc: "Silence all informational output.",
+      aliases: "-q",
       default: false
     class_option :debug,
       type: :boolean,
-      desc: 'Output debug information',
-      aliases: '-d',
+      desc: "Output debug information",
+      aliases: "-d",
       default: false
 
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :path,
       type: :string,
-      aliases: '-p',
+      aliases: "-p",
       hide: true
-    desc 'install', 'Install the cookbooks specified in the Berksfile'
+    desc "install", "Install the cookbooks specified in the Berksfile"
     def install
-      if options[:path]
-        # TODO: Remove in Berkshelf 4.0
-        Berkshelf.formatter.deprecation "`berks install --path [PATH]` has been replaced by `berks vendor`."
-        Berkshelf.formatter.deprecation "Re-run your command as `berks vendor [PATH]` or see `berks help vendor`."
-        exit(1)
-      end
-
       berksfile = Berksfile.from_options(options)
       berksfile.install
     end
@@ -146,18 +134,18 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
-    desc 'update [COOKBOOKS]', 'Update the cookbooks (and dependencies) specified in the Berksfile'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
+    desc "update [COOKBOOKS]", "Update the cookbooks (and dependencies) specified in the Berksfile"
     def update(*cookbook_names)
       berksfile = Berksfile.from_options(options)
       berksfile.update(*cookbook_names)
@@ -166,70 +154,69 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
     method_option :no_freeze,
       type: :boolean,
       default: false,
-      desc: 'Do not freeze uploaded cookbook(s).'
+      desc: "Do not freeze uploaded cookbook(s)."
     method_option :force,
       type: :boolean,
       default: false,
-      desc: 'Upload all cookbooks even if a frozen one exists on the Chef Server.'
+      desc: "Upload all cookbooks even if a frozen one exists on the Chef Server."
     method_option :ssl_verify,
       type: :boolean,
       default: nil,
-      desc: 'Disable/Enable SSL verification when uploading cookbooks.'
+      desc: "Disable/Enable SSL verification when uploading cookbooks."
     method_option :skip_syntax_check,
       type: :boolean,
       default: false,
-      desc: 'Skip Ruby syntax check when uploading cookbooks.',
-      aliases: '-s'
+      desc: "Skip Ruby syntax check when uploading cookbooks.",
+      aliases: "-s"
     method_option :halt_on_frozen,
       type: :boolean,
       default: false,
-      desc: 'Exit with a non zero exit code if the Chef Server already has the version of the cookbook(s).'
-    desc 'upload [COOKBOOKS]', 'Upload the cookbook specified in the Berksfile to the Chef Server'
+      desc: "Exit with a non zero exit code if the Chef Server already has the version of the cookbook(s)."
+    desc "upload [COOKBOOKS]", "Upload the cookbook specified in the Berksfile to the Chef Server"
     def upload(*names)
       berksfile = Berksfile.from_options(options)
 
       options[:freeze]    = !options[:no_freeze]
       options[:validate]  = false if options[:skip_syntax_check]
-
-      berksfile.upload(names, options.symbolize_keys)
+      berksfile.upload(names, options.each_with_object({}) { |(k, v), m| m[k.to_sym] = v })
     end
 
     method_option :envfile,
       type: :string,
-      desc: 'Path to a JSON environment file to update.',
-      aliases: '-f'
+      desc: "Path to a JSON environment file to update.",
+      aliases: "-f"
     method_option :lockfile,
       type: :string,
       default: Berkshelf::Lockfile::DEFAULT_FILENAME,
-      desc: 'Path to a Berksfile.lock to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile.lock to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :ssl_verify,
       type: :boolean,
       default: nil,
-      desc: 'Disable/Enable SSL verification when locking cookbooks.'
-    desc 'apply ENVIRONMENT', 'Apply version locks from Berksfile.lock to a Chef environment'
+      desc: "Disable/Enable SSL verification when locking cookbooks."
+    desc "apply ENVIRONMENT", "Apply version locks from Berksfile.lock to a Chef environment"
     def apply(environment_name)
       unless File.exist?(options[:lockfile])
         raise LockfileNotFound, "No lockfile found at #{options[:lockfile]}"
       end
 
       lockfile     = Lockfile.from_file(options[:lockfile])
-      lock_options = Hash[options].symbolize_keys
+      lock_options = Hash[options].each_with_object({}) { |(k, v), m| m[k.to_sym] = v }
 
       lockfile.apply(environment_name, lock_options)
     end
@@ -237,66 +224,56 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
-    desc 'outdated [COOKBOOKS]', 'List dependencies that have new versions available that satisfy their constraints'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
+    method_option :all,
+      type: :boolean,
+      desc: "Include cookbooks that don't satisfy the version constraints.",
+      aliases: "-a",
+      default: false
+    desc "outdated [COOKBOOKS]", "List dependencies that have new versions available that satisfy their constraints"
     def outdated(*names)
       berksfile = Berksfile.from_options(options)
-      outdated  = berksfile.outdated(*names)
+      outdated  = berksfile.outdated(*names, include_non_satisfying: options[:all])
       Berkshelf.formatter.outdated(outdated)
     end
 
     method_option :source,
       type: :string,
       default: Berksfile::DEFAULT_API_URL,
-      desc: 'URL to search for sources',
-      banner: 'URL'
-    desc 'search NAME', 'Search the remote source for cookbooks matching the partial name'
+      desc: "URL to search for sources",
+      banner: "URL"
+    desc "search NAME", "Search the remote source for cookbooks matching the partial name"
     def search(name)
-      source = Source.new(options[:source])
+      source = Source.new(nil, options[:source])
       cookbooks = source.search(name)
       Berkshelf.formatter.search(cookbooks)
     end
 
-    desc 'init [PATH]', 'Initialize Berkshelf in the given directory'
-    def init(path = '.')
-      Berkshelf.formatter.deprecation <<EOF
-This command is being deprecated in favor of `chef generate cookbook` and will soon return an error.
-Please use `chef generate cookbook` instead of this command.
-EOF
-      Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
-      Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
-
-      Berkshelf::InitGenerator.new([path], options).invoke_all
-
-      Berkshelf.formatter.msg 'Successfully initialized'
-    end
-    tasks['init'].options = Berkshelf::InitGenerator.class_options
-
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
-    desc 'list', 'List cookbooks and their dependencies specified by your Berksfile'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
+    desc "list", "List cookbooks and their dependencies specified by your Berksfile"
     def list
       berksfile = Berksfile.from_options(options)
       Berkshelf.formatter.list(berksfile.list)
@@ -331,10 +308,10 @@ EOF
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
-    desc 'contingent COOKBOOK', 'List all cookbooks that depend on the given cookbook in your Berksfile'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
+    desc "contingent COOKBOOK", "List all cookbooks that depend on the given cookbook in your Berksfile"
     def contingent(name)
       berksfile    = Berksfile.from_options(options)
       dependencies = berksfile.cookbooks.select do |cookbook|
@@ -352,9 +329,9 @@ EOF
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :except,
       type: :array,
       desc: "Exclude cookbooks that are in these groups.",
@@ -377,22 +354,22 @@ EOF
 
     method_option :except,
       type: :array,
-      desc: 'Exclude cookbooks that are in these groups.',
-      aliases: '-e'
+      desc: "Exclude cookbooks that are in these groups.",
+      aliases: "-e"
     method_option :delete,
       type: :boolean,
       desc: "Clean the target directory before vendoring",
       default: false
     method_option :only,
       type: :array,
-      desc: 'Only cookbooks that are in these groups.',
-      aliases: '-o'
+      desc: "Only cookbooks that are in these groups.",
+      aliases: "-o"
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     desc "vendor [PATH]", "Vendor the cookbooks specified by the Berksfile into a directory"
     def vendor(path = File.join(Dir.pwd, "berks-cookbooks"))
       berksfile = Berkshelf::Berksfile.from_options(options)
@@ -412,53 +389,45 @@ EOF
     method_option :berksfile,
       type: :string,
       default: nil,
-      desc: 'Path to a Berksfile to operate off of.',
-      aliases: '-b',
-      banner: 'PATH'
+      desc: "Path to a Berksfile to operate off of.",
+      aliases: "-b",
+      banner: "PATH"
     method_option :outfile,
       type: :string,
-      default: 'graph.png',
-      desc: 'The name of the output file',
-      aliases: '-o',
-      banner: 'NAME'
+      default: "graph.png",
+      desc: "The name of the output file",
+      aliases: "-o",
+      banner: "NAME"
+    method_option :outfile_format,
+      type: :string,
+      default: "png",
+      desc: "The format of the output file, either png or dot.",
+      aliases: "-f",
+      banner: "FORMAT"
     desc "viz", "Visualize the dependency graph"
     def viz
       berksfile = Berksfile.from_options(options)
-      path = berksfile.viz(options[:outfile])
+      path = berksfile.viz(options[:outfile], options[:outfile_format])
 
       Berkshelf.ui.info(path)
     end
 
-    desc 'version', 'Display version'
+    desc "version", "Display version"
     def version
       Berkshelf.formatter.version
     end
 
-    desc 'cookbook NAME [PATH]', 'Create a skeleton for a new cookbook'
-    def cookbook(name, path = nil)
-      Berkshelf.formatter.deprecation <<EOF
-This command is being deprecated in favor of `chef generate cookbook` and will soon return an error.
-Please use `chef generate cookbook` instead of this command.
-EOF
-      path = File.join(Dir.pwd, name) if path.nil?
-      Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
-      Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
-
-      Berkshelf::CookbookGenerator.new([path, name], options).invoke_all
-    end
-    tasks['cookbook'].options = Berkshelf::CookbookGenerator.class_options
-
     private
 
-      # Print a list of the given cookbooks. This is used by various
-      # methods like {list} and {contingent}.
-      #
-      # @param [Array<CachedCookbook>] cookbooks
-      #
-      def print_list(cookbooks)
-        Array(cookbooks).sort.each do |cookbook|
-          Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
-        end
+    # Print a list of the given cookbooks. This is used by various
+    # methods like {list} and {contingent}.
+    #
+    # @param [Array<CachedCookbook>] cookbooks
+    #
+    def print_list(cookbooks)
+      Array(cookbooks).sort.each do |cookbook|
+        Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
       end
+    end
   end
 end