berkshelf 2.0.0.beta → 2.0.0

data/lib/berkshelf/chef/cookbook.rb

@@ -1,6 +1,5 @@
 module Berkshelf::Chef
-  # @author Jamie Winsor <reset@riotgames.com>
   module Cookbook
-    autoload :Chefignore, 'berkshelf/chef/cookbook/chefignore'
+    require_relative 'cookbook/chefignore'
   end
 end

data/lib/berkshelf/chef/cookbook/chefignore.rb

@@ -30,7 +30,7 @@ module Berkshelf::Chef::Cookbook
       end
     end
 
-    FILENAME                = "chefignore".freeze
+    FILENAME                = 'chefignore'.freeze
     COMMENTS_AND_WHITESPACE = /^\s*(?:#.*)?$/
 
     attr_reader :ignores

data/lib/berkshelf/cli.rb

@@ -1,7 +1,12 @@
 require 'berkshelf'
+require_relative 'config'
+require_relative 'init_generator'
+require_relative 'cookbook_generator'
+
+require 'berkshelf/commands/test_command'
+require 'berkshelf/commands/shelf'
 
 module Berkshelf
-  # @author Jamie Winsor <reset@riotgames.com>
   class Cli < Thor
     class << self
       def dispatch(meth, given_args, given_opts, config)
@@ -15,7 +20,7 @@ module Berkshelf
           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
@@ -25,7 +30,7 @@ module Berkshelf
 
       if @options[:config]
         unless File.exist?(@options[:config])
-          raise BerksConfigNotFound, "You specified a path to a configuration file that did not exist: '#{@options[:config]}'"
+          raise ConfigNotFound.new(:berkshelf, @options[:config])
         end
         Berkshelf::Config.path = @options[:config]
       end
@@ -42,7 +47,7 @@ module Berkshelf
       @options = options.dup # unfreeze frozen options Hash from Thor
     end
 
-    namespace "berkshelf"
+    namespace 'berkshelf'
 
     map 'in'   => :install
     map 'up'   => :upload
@@ -55,52 +60,52 @@ module Berkshelf
 
     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 :force,
       type: :boolean,
       default: false,
-      desc: "create a new configuration file even if one already exists."
+      desc: 'create a new configuration file even if one already exists.'
     method_option :path,
       type: :string,
       default: Berkshelf::Config.path,
       desc: 'The path to save the configuration file'
-    desc "configure", "Create a new configuration file to customize Berkshelf's behavior"
+    desc 'configure', 'Create a new Berkshelf configuration file'
     def configure
       path = File.expand_path(options[:path])
 
       if File.exist?(path) && !options[:force]
-        raise Berkshelf::ConfigExists, "A configuration file already exists. Re-run with the --force flag if you wish to overwrite it."
+        raise Berkshelf::ConfigExists, 'A configuration file already exists. Re-run with the --force flag if you wish to overwrite it.'
       end
 
       @config = Berkshelf::Config.new(path)
 
       [
-        "chef.chef_server_url",
-        "chef.node_name",
-        "chef.client_key",
-        "chef.validation_client_name",
-        "chef.validation_key_path",
-        "vagrant.vm.box",
-        "vagrant.vm.box_url",
+        'chef.chef_server_url',
+        'chef.node_name',
+        'chef.client_key',
+        'chef.validation_client_name',
+        'chef.validation_key_path',
+        'vagrant.vm.box',
+        'vagrant.vm.box_url',
       ].each do |attribute|
         default = @config.get_attribute(attribute)
 
@@ -124,41 +129,26 @@ module Berkshelf
       Berkshelf.formatter.msg "Config written to: '#{path}'"
     end
 
-    desc "open NAME", "Opens the source directory of an installed cookbook"
-    def open(name)
-      editor = [ENV['BERKSHELF_EDITOR'], ENV['VISUAL'], ENV['EDITOR']].find{|e| !e.nil? && !e.empty? }
-      raise ArgumentError, "To open a cookbook, set $EDITOR or $BERKSHELF_EDITOR" unless editor
-
-      cookbook = Berkshelf.cookbook_store.cookbooks(name).last
-      raise CookbookNotFound, "Cookbook '#{name}' not found in any of the sources!" unless cookbook
-
-      Dir.chdir(cookbook.path) do
-        command = "#{editor} #{cookbook.path}"
-        success = system(command)
-        raise CommandUnsuccessful, "Could not run `#{command}`" unless success
-      end
-    end
-
     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: Berkshelf::DEFAULT_FILENAME,
-      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,
-      desc: "Path to install cookbooks to (i.e. vendor/cookbooks).",
-      aliases: "-p",
-      banner: "PATH"
-    desc "install", "Install the Cookbooks specified by a Berksfile or a Berksfile.lock"
+      desc: 'Path to install cookbooks to (i.e. vendor/cookbooks).',
+      aliases: '-p',
+      banner: 'PATH'
+    desc 'install', 'Install the cookbooks specified in the Berksfile'
     def install
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.install(options)
@@ -167,18 +157,18 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      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 all Cookbooks and their dependencies specified by a Berksfile to their latest versions"
+      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_file(options[:berksfile])
 
@@ -192,44 +182,44 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      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 cookbook(s) even if a frozen one exists on the Chef Server."
+      desc: 'Upload all cookbook(s) 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 :skip_dependencies,
       type: :boolean,
-      desc: "Skip uploading dependent cookbook(s).",
+      desc: 'Skip uploading dependent cookbook(s).',
       default: false,
-      aliases: "-D"
+      aliases: '-D'
     method_option :halt_on_frozen,
       type: :boolean,
       default: false,
-      desc: "Halt uploading and exit if the Chef Server has a frozen version of the cookbook(s)."
-    desc "upload [COOKBOOKS]", "Upload cookbook(s) specified by a Berksfile to the configured Chef Server."
+      desc: 'Halt uploading and exit if the Chef Server has a frozen version of the cookbook(s).'
+    desc 'upload [COOKBOOKS]', 'Upload the cookbook specified in the Berksfile to the Chef Server'
     def upload(*cookbook_names)
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
 
@@ -243,14 +233,14 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      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 :ssl_verify,
       type: :boolean,
       default: nil,
-      desc: "Disable/Enable SSL verification when locking cookbooks."
-    desc "apply ENVIRONMENT", "Apply cookbook locks of your Berksfile.lock to the target Chef environment."
+      desc: 'Disable/Enable SSL verification when locking cookbooks.'
+    desc 'apply ENVIRONMENT', 'Apply the cookbook version locks from Berksfile.lock to a Chef environment'
     def apply(environment_name)
       berksfile    = ::Berkshelf::Berksfile.from_file(options[:berksfile])
       lock_options = Hash[options].symbolize_keys
@@ -261,24 +251,24 @@ module Berkshelf
     method_option :berksfile,
       type: :string,
       default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      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]", "Show all outdated cookbooks (exclusively from the community site)"
+      desc: 'Only cookbooks that are in these groups.',
+      aliases: '-o'
+    desc 'outdated [COOKBOOKS]', 'Show outdated cookbooks (from the community site)'
     def outdated(*cookbook_names)
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
-      Berkshelf.formatter.msg "Listing outdated cookbooks with newer versions available..."
-      Berkshelf.formatter.msg "BETA: this feature will only pull differences from the community site and will"
-      Berkshelf.formatter.msg "BETA: ignore all other sources you may have defined"
-      Berkshelf.formatter.msg ""
+      Berkshelf.formatter.msg 'Listing outdated cookbooks with newer versions available...'
+      Berkshelf.formatter.msg 'BETA: this feature will only pull differences from the community site and will'
+      Berkshelf.formatter.msg 'BETA: ignore all other sources you may have defined'
+      Berkshelf.formatter.msg ''
 
       outdated_options = {
         cookbooks: cookbook_names
@@ -287,7 +277,7 @@ module Berkshelf
       outdated = berksfile.outdated(outdated_options)
 
       if outdated.empty?
-        Berkshelf.formatter.msg "All cookbooks up to date"
+        Berkshelf.formatter.msg 'All cookbooks up to date'
       else
         outdated.each do |cookbook, latest_version|
           Berkshelf.formatter.msg "Cookbook '#{cookbook.name} (#{cookbook.version_constraint})' is outdated (#{latest_version})"
@@ -295,10 +285,10 @@ module Berkshelf
       end
     end
 
-    desc "init [PATH]", "Prepare a local path to have its Cookbook dependencies managed by Berkshelf"
+    desc 'init [PATH]', 'Initialize Berkshelf in the given directory'
     def init(path = Dir.pwd)
-      Berkshelf.formatter.deprecation "--git is now the default" if options[:git]
-      Berkshelf.formatter.deprecation "--vagrant is now the default" if options[:vagrant]
+      Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
+      Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
 
       if File.chef_cookbook?(path)
         options[:chefignore] = true
@@ -307,152 +297,105 @@ module Berkshelf
 
       ::Berkshelf::InitGenerator.new([path], options).invoke_all
 
-      ::Berkshelf.formatter.msg "Successfully initialized"
+      ::Berkshelf.formatter.msg 'Successfully initialized'
     end
-    tasks["init"].options = Berkshelf::InitGenerator.class_options
 
     method_option :berksfile,
       type: :string,
-      default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      desc: "Path to a Berksfile to operate off of.",
-      aliases: "-b",
-      banner: "PATH"
-    desc "list", "Show all of the cookbooks in the current Berkshelf"
+      default: Berkshelf::DEFAULT_FILENAME,
+      desc: 'Path to a Berksfile to operate off of.',
+      aliases: '-b',
+      banner: 'PATH'
+    desc 'list', 'List all cookbooks (and dependencies) specified in the Berksfile'
     def list
-      berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile = Berksfile.from_file(options[:berksfile])
+      sources = Berkshelf.ui.mute { berksfile.resolve(berksfile.sources)[:solution] }.sort
 
-      Berkshelf.formatter.msg "Cookbooks installed by your Berksfile:"
-      Berkshelf.ui.mute { berksfile.resolve(berksfile.sources)[:solution] }.sort.each do |cookbook|
-        Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
+      if sources.empty?
+        Berkshelf.formatter.msg 'There are no cookbooks installed by your Berksfile'
+      else
+        Berkshelf.formatter.msg 'Cookbooks installed by your Berksfile:'
+        print_list(sources)
       end
     end
 
     method_option :berksfile,
       type: :string,
-      default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
+      default: Berkshelf::DEFAULT_FILENAME,
       desc: "Path to a Berksfile to operate off of.",
       aliases: "-b",
       banner: "PATH"
-    desc "show COOKBOOK", "Display the source path on the local file system for the given cookbook"
+    desc "show [COOKBOOK]", "Display name, author, copyright, and dependency information about a cookbook"
     def show(name)
-      berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
-      source = berksfile.find(name)
+      berksfile = Berksfile.from_file(options[:berksfile])
 
       cookbook = Berkshelf.ui.mute {
-        berksfile.resolve(source)[:solution].first
+        berksfile.resolve(berksfile.find(name))[:solution].first
       }
 
-      raise CookbookNotFound, "Cookbook '#{name}' was not installed by your Berksfile" unless cookbook
-      Berkshelf.formatter.msg(cookbook.path)
-    end
+      raise CookbookNotFound, "Cookbook '#{name}' is not installed by your Berksfile" unless cookbook
 
-    method_option :version,
-      type: :string,
-      desc: 'The version of the cookbook to display.',
-      aliases: '-v'
-    desc "info [COOKBOOK]", "Display name, author, copyright, and dependency information about a cookbook"
-    def info(name)
-      if options[:version]
-        cookbook = Berkshelf.cookbook_store.cookbook(name, options[:version])
-      else
-        cookbook = Berkshelf.cookbook_store.cookbooks(name).sort_by(&:version).last
-      end
-
-      raise CookbookNotFound, "Cookbook '#{name}' was not installed by your Berksfile" if cookbook.nil?
-      Berkshelf.formatter.msg(cookbook.pretty_print)
+      Berkshelf.formatter.show(cookbook)
     end
 
     method_option :berksfile,
       type: :string,
-      default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      desc: "Path to a Berksfile to operate off of.",
-      aliases: "-b",
-      banner: "PATH"
-    desc "contingent COOKBOOK", "Display a list of cookbooks that depend on the given cookbook"
+      default: Berkshelf::DEFAULT_FILENAME,
+      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'
     def contingent(name)
-      berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile = Berksfile.from_file(options[:berksfile])
 
-      Berkshelf.formatter.msg "Cookbooks contingent upon #{name}:"
-      sources = Berkshelf.ui.mute { berksfile.resolve(berksfile.sources)[:solution] }.sort.each do |cookbook|
-        if cookbook.dependencies.include?(name)
-          Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
-        end
+      sources = Berkshelf.ui.mute { berksfile.resolve(berksfile.sources)[:solution] }.sort
+      dependencies = sources.select { |cookbook| cookbook.dependencies.include?(name) }
+
+      if dependencies.empty?
+        Berkshelf.formatter.msg "There are no cookbooks contingent upon '#{name}' defined in this Berksfile"
+      else
+        Berkshelf.formatter.msg "Cookbooks in this Berksfile contingent upon #{name}:"
+        print_list(dependencies)
       end
     end
 
     method_option :berksfile,
       type: :string,
       default: File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME),
-      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 :output,
       type: :string,
       default: Dir.pwd,
-      desc: "Path to output the tarball",
-      aliases: "-o",
-      banner: "PATH"
+      desc: 'Path to output the tarball',
+      aliases: '-o',
+      banner: 'PATH'
     method_option :skip_dependencies,
       type: :boolean,
-      desc: "Skip packaging dependent cookbook(s).",
+      desc: 'Skip packaging dependent cookbook(s).',
       default: false
     method_option :ignore_chefignore,
       type: :boolean,
-      desc: "Do not apply the chefignore to the packaged contents",
+      desc: 'Do not apply the chefignore to the packaged contents',
       default: false
-    desc "package [COOKBOOK]", "Package this cookbook and all it's dependencies in a tarball"
+    desc 'package [COOKBOOK]', 'Package a cookbook (and dependencies) as a tarball'
     def package(name = nil)
       berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.package(name, options)
     end
 
-    desc "version", "Display version and copyright information"
+    desc 'version', 'Display version and copyright information'
     def version
       Berkshelf.formatter.msg version_header
       Berkshelf.formatter.msg "\n"
       Berkshelf.formatter.msg license
     end
 
-    method_option :foodcritic,
-      type: :boolean,
-      desc: "Creates a Thorfile with Foodcritic support to lint test your cookbook"
-    method_option :chef_minitest,
-      type: :boolean,
-      desc: "Creates chef-minitest support files and directories, adds minitest-handler cookbook to run_list of Vagrantfile"
-    method_option :scmversion,
-      type: :boolean,
-      desc: "Creates a Thorfile with SCMVersion support to manage versions for continuous integration"
-    method_option :license,
-      type: :string,
-      desc: "License for cookbook (apachev2, gplv2, gplv3, mit, reserved)",
-      aliases: "-L"
-    method_option :maintainer,
-      type: :string,
-      desc: "Name of cookbook maintainer",
-      aliases: "-m"
-    method_option :maintainer_email,
-      type: :string,
-      desc: "Email address of cookbook maintainer",
-      aliases: "-e"
-    method_option :no_bundler,
-      type: :boolean,
-      desc: "Skips generation of a Gemfile and other Bundler specific support"
-    method_option :vagrant,
-      type: :boolean,
-      hide: true
-    method_option :skip_vagrant,
-      type: :boolean,
-      desc: "Skips adding a Vagrantfile and adding supporting gems to the Gemfile"
-    method_option :git,
-      type: :boolean,
-      hide: true
-    method_option :skip_git,
-      type: :boolean,
-      desc: "Skips adding a .gitignore and running git init in the cookbook directory"
-    desc "cookbook NAME", "Create a skeleton for a new cookbook"
+    desc 'cookbook NAME', 'Create a skeleton for a new cookbook'
     def cookbook(name)
-      Berkshelf.formatter.deprecation "--git is now the default" if options[:git]
-      Berkshelf.formatter.deprecation "--vagrant is now the default" if options[:vagrant]
+      Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
+      Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
 
       unless Config.instance.valid?
         raise InvalidConfiguration.new(Config.instance.errors)
@@ -460,6 +403,7 @@ module Berkshelf
 
       ::Berkshelf::CookbookGenerator.new([File.join(Dir.pwd, name), name], options).invoke_all
     end
+    tasks['cookbook'].options = Berkshelf::CookbookGenerator.class_options
 
     private
 
@@ -470,10 +414,16 @@ module Berkshelf
       def license
         File.read(Berkshelf.root.join('LICENSE'))
       end
-  end
-end
 
-Dir["#{File.dirname(__FILE__)}/cli_commands/*.rb"].sort.each do |path|
-  require "berkshelf/cli_commands/#{File.basename(path, '.rb')}"
+      # 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).each do |cookbook|
+          Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
+        end
+      end
+  end
 end
-