chef 14.2.0 → 14.3.37

data/lib/chef/run_context.rb

@@ -331,12 +331,12 @@ class Chef
       cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name, current_cookbook: current_cookbook)
 
       if unreachable_cookbook?(cookbook_name) # CHEF-4367
-        logger.warn(<<-ERROR_MESSAGE)
-MissingCookbookDependency:
-Recipe `#{recipe_name}` is not in the run_list, and cookbook '#{cookbook_name}'
-is not a dependency of any cookbook in the run_list.  To load this recipe,
-first add a dependency on cookbook '#{cookbook_name}' in the cookbook you're
-including it from in that cookbook's metadata.
+        logger.warn(<<~ERROR_MESSAGE)
+          MissingCookbookDependency:
+          Recipe `#{recipe_name}` is not in the run_list, and cookbook '#{cookbook_name}'
+          is not a dependency of any cookbook in the run_list.  To load this recipe,
+          first add a dependency on cookbook '#{cookbook_name}' in the cookbook you're
+          including it from in that cookbook's metadata.
 ERROR_MESSAGE
       end
 
@@ -433,7 +433,7 @@ ERROR_MESSAGE
     # @return [Boolean] `true` if the recipe has been loaded, `false` otherwise.
     #
     def loaded_fully_qualified_recipe?(cookbook, recipe)
-      loaded_recipes_hash.has_key?("#{cookbook}::#{recipe}")
+      loaded_recipes_hash.key?("#{cookbook}::#{recipe}")
     end
 
     #
@@ -468,7 +468,7 @@ ERROR_MESSAGE
     # @return [Boolean] `true` if the recipe has been loaded, `false` otherwise.
     #
     def loaded_fully_qualified_attribute?(cookbook, attribute_file)
-      loaded_attributes_hash.has_key?("#{cookbook}::#{attribute_file}")
+      loaded_attributes_hash.key?("#{cookbook}::#{attribute_file}")
     end
 
     #

data/lib/chef/run_list/run_list_expansion.rb

@@ -112,7 +112,7 @@ class Chef
       end
 
       def applied_role?(role_name)
-        @applied_roles.has_key?(role_name)
+        @applied_roles.key?(role_name)
       end
 
       # Returns an array of role names that were expanded; this
@@ -148,8 +148,8 @@ class Chef
       end
 
       def to_hash
-        seen_items = { :recipe => {}, :role => {} }
-        { :id => @environment, :run_list => convert_run_list_trace("top level", seen_items) }
+        seen_items = { recipe: {}, role: {} }
+        { id: @environment, run_list: convert_run_list_trace("top level", seen_items) }
       end
 
       private
@@ -185,12 +185,12 @@ class Chef
           seen_items[item.type][item.name] = true
           case item.type
             when :recipe
-              { :type => "recipe", :name => item.name, :version => item.version, :skipped => !!skipped }
+              { type: "recipe", name: item.name, version: item.version, skipped: !!skipped }
             when :role
               error = @role_errors[item.name]
               missing = @all_missing_roles[item.name]
-              { :type => :role, :name => item.name, :children => (missing || error || skipped) ? [] : convert_run_list_trace(item.to_s, seen_items),
-                :missing => missing, :error => error, :skipped => skipped }
+              { type: :role, name: item.name, children: (missing || error || skipped) ? [] : convert_run_list_trace(item.to_s, seen_items),
+                missing: missing, error: error, skipped: skipped }
           end
         end
       end

data/lib/chef/run_list/run_list_item.rb

@@ -32,7 +32,7 @@ class Chef
           assert_hash_is_valid_run_list_item!(item)
           @type = (item["type"] || item[:type]).to_sym
           @name = item["name"] || item[:name]
-          if item.has_key?("version") || item.has_key?(:version)
+          if item.key?("version") || item.key?(:version)
             @version = item["version"] || item[:version]
           end
         when String

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -30,7 +30,7 @@ class Chef
       end
 
       def add_recipe(name, version = nil)
-        if version && @versions.has_key?(name)
+        if version && @versions.key?(name)
           unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
             raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
           end
@@ -40,7 +40,7 @@ class Chef
       end
 
       def with_versions
-        map { |recipe_name| { :name => recipe_name, :version => @versions[recipe_name] } }
+        map { |recipe_name| { name: recipe_name, version: @versions[recipe_name] } }
       end
 
       # Return an Array of Hashes, each of the form:
@@ -48,7 +48,7 @@ class Chef
       def with_version_constraints
         map do |recipe_name|
           constraint = Chef::VersionConstraint.new(@versions[recipe_name])
-          { :name => recipe_name, :version_constraint => constraint }
+          { name: recipe_name, version_constraint: constraint }
         end
       end
 

data/lib/chef/run_status.rb

@@ -104,16 +104,16 @@ class Chef::RunStatus
   # * :backtrace
   def to_hash
     # use a flat hash here so we can't errors from intermediate values being nil
-    { :node => node,
-      :success => success?,
-      :start_time => start_time,
-      :end_time => end_time,
-      :elapsed_time => elapsed_time,
-      :all_resources => all_resources,
-      :updated_resources => updated_resources,
-      :exception => formatted_exception,
-      :backtrace => backtrace,
-      :run_id => run_id }
+    { node: node,
+      success: success?,
+      start_time: start_time,
+      end_time: end_time,
+      elapsed_time: elapsed_time,
+      all_resources: all_resources,
+      updated_resources: updated_resources,
+      exception: formatted_exception,
+      backtrace: backtrace,
+      run_id: run_id }
   end
 
   # Returns a string of the format "ExceptionClass: message" or +nil+ if no

data/lib/chef/shell.rb

@@ -207,91 +207,91 @@ module Shell
 
     banner("chef-shell #{Chef::VERSION}\n\nUsage: chef-shell [NAMED_CONF] (OPTIONS)")
 
-    footer(<<-FOOTER)
-When no CONFIG is specified, chef-shell attempts to load a default configuration file:
-* If a NAMED_CONF is given, chef-shell will load ~/.chef/NAMED_CONF/chef_shell.rb
-* If no NAMED_CONF is given chef-shell will load ~/.chef/chef_shell.rb if it exists
-* If no chef_shell.rb can be found, chef-shell falls back to load:
-      /etc/chef/client.rb if -z option is given.
-      /etc/chef/solo.rb   if --solo-legacy-mode option is given.
-      .chef/knife.rb      if -s option is given.
+    footer(<<~FOOTER)
+      When no CONFIG is specified, chef-shell attempts to load a default configuration file:
+      * If a NAMED_CONF is given, chef-shell will load ~/.chef/NAMED_CONF/chef_shell.rb
+      * If no NAMED_CONF is given chef-shell will load ~/.chef/chef_shell.rb if it exists
+      * If no chef_shell.rb can be found, chef-shell falls back to load:
+            /etc/chef/client.rb if -z option is given.
+            /etc/chef/solo.rb   if --solo-legacy-mode option is given.
+            .chef/knife.rb      if -s option is given.
 FOOTER
 
     option :config_file,
-      :short => "-c CONFIG",
-      :long  => "--config CONFIG",
-      :description => "The configuration file to use"
+      short: "-c CONFIG",
+      long: "--config CONFIG",
+      description: "The configuration file to use"
 
     option :help,
-      :short        => "-h",
-      :long         => "--help",
-      :description  => "Show this message",
-      :on           => :tail,
-      :boolean      => true,
-      :proc         => proc { print_help }
+      short: "-h",
+      long: "--help",
+      description: "Show this message",
+      on: :tail,
+      boolean: true,
+      proc: proc { print_help }
 
     option :log_level,
-      :short  => "-l LOG_LEVEL",
-      :long   => "--log-level LOG_LEVEL",
-      :description => "Set the logging level",
-      :proc         => proc { |level| Chef::Config.log_level = level.to_sym; Shell.setup_logger }
+      short: "-l LOG_LEVEL",
+      long: "--log-level LOG_LEVEL",
+      description: "Set the logging level",
+      proc: proc { |level| Chef::Config.log_level = level.to_sym; Shell.setup_logger }
 
     option :standalone,
-      :short        => "-a",
-      :long         => "--standalone",
-      :description  => "standalone session",
-      :default      => true,
-      :boolean      => true
+      short: "-a",
+      long: "--standalone",
+      description: "standalone session",
+      default: true,
+      boolean: true
 
     option :solo_shell,
-      :short        => "-s",
-      :long         => "--solo",
-      :description  => "chef-solo session",
-      :boolean      => true,
-      :proc         => proc { Chef::Config[:solo] = true }
+      short: "-s",
+      long: "--solo",
+      description: "chef-solo session",
+      boolean: true,
+      proc: proc { Chef::Config[:solo] = true }
 
     option :client,
-      :short        => "-z",
-      :long         => "--client",
-      :description  => "chef-client session",
-      :boolean      => true
+      short: "-z",
+      long: "--client",
+      description: "chef-client session",
+      boolean: true
 
     option :solo_legacy_shell,
-      :long         => "--solo-legacy-mode",
-      :description  => "chef-solo legacy session",
-      :boolean      => true,
-      :proc         => proc { Chef::Config[:solo_legacy_mode] = true }
+      long: "--solo-legacy-mode",
+      description: "chef-solo legacy session",
+      boolean: true,
+      proc: proc { Chef::Config[:solo_legacy_mode] = true }
 
     option :json_attribs,
-      :short => "-j JSON_ATTRIBS",
-      :long => "--json-attributes JSON_ATTRIBS",
-      :description => "Load attributes from a JSON file or URL",
-      :proc => nil
+      short: "-j JSON_ATTRIBS",
+      long: "--json-attributes JSON_ATTRIBS",
+      description: "Load attributes from a JSON file or URL",
+      proc: nil
 
     option :chef_server_url,
-      :short => "-S CHEFSERVERURL",
-      :long => "--server CHEFSERVERURL",
-      :description => "The chef server URL",
-      :proc => nil
+      short: "-S CHEFSERVERURL",
+      long: "--server CHEFSERVERURL",
+      description: "The chef server URL",
+      proc: nil
 
     option :version,
-      :short        => "-v",
-      :long         => "--version",
-      :description  => "Show chef version",
-      :boolean      => true,
-      :proc         => lambda { |v| puts "Chef: #{::Chef::VERSION}" },
-      :exit         => 0
+      short: "-v",
+      long: "--version",
+      description: "Show chef version",
+      boolean: true,
+      proc: lambda { |v| puts "Chef: #{::Chef::VERSION}" },
+      exit: 0
 
     option :override_runlist,
-      :short        => "-o RunlistItem,RunlistItem...",
-      :long         => "--override-runlist RunlistItem,RunlistItem...",
-      :description  => "Replace current run list with specified items",
-      :proc         => lambda { |items| items.split(",").map { |item| Chef::RunList::RunListItem.new(item) } }
+      short: "-o RunlistItem,RunlistItem...",
+      long: "--override-runlist RunlistItem,RunlistItem...",
+      description: "Replace current run list with specified items",
+      proc: lambda { |items| items.split(",").map { |item| Chef::RunList::RunListItem.new(item) } }
 
     option :skip_cookbook_sync,
-      :long           => "--[no-]skip-cookbook-sync",
-      :description    => "Use cached cookbooks without overwriting local differences from the server",
-      :boolean        => false
+      long: "--[no-]skip-cookbook-sync",
+      description: "Use cached cookbooks without overwriting local differences from the server",
+      boolean: false
 
     def self.print_help
       instance = new

data/lib/chef/shell/ext.rb

@@ -190,12 +190,12 @@ module Shell
       extend Shell::Extensions::ObjectCoreExtensions
 
       desc "prints this help message"
-      explain(<<-E)
-## SUMMARY ##
-  When called with no argument, +help+ prints a table of all
-  chef-shell commands. When called with an argument COMMAND, +help+
-  prints a detailed explanation of the command if available, or the
-  description if no explanation is available.
+      explain(<<~E)
+        ## SUMMARY ##
+          When called with no argument, +help+ prints a table of all
+          chef-shell commands. When called with an argument COMMAND, +help+
+          prints a detailed explanation of the command if available, or the
+          description if no explanation is available.
       E
       def help(commmand = nil)
         if commmand
@@ -239,10 +239,10 @@ module Shell
       end
 
       desc "returns an object to control a paused chef run"
-      subcommands :resume       => "resume the chef run",
-                  :step         => "run only the next resource",
-                  :skip_back    => "move back in the run list",
-                  :skip_forward => "move forward in the run list"
+      subcommands resume: "resume the chef run",
+                  step: "run only the next resource",
+                  skip_back: "move back in the run list",
+                  skip_forward: "move forward in the run list"
       def chef_run
         Shell.session.resource_collection.iterator
       end
@@ -302,18 +302,18 @@ module Shell
 
     RESTApiExtensions = Proc.new do
       desc "edit an object in your EDITOR"
-      explain(<<-E)
-## SUMMARY ##
-  +edit(object)+ allows you to edit any object that can be converted to JSON.
-  When finished editing, this method will return the edited object:
-
-      new_node = edit(existing_node)
-
-## EDITOR SELECTION ##
-  chef-shell looks for an editor using the following logic
-  1. Looks for an EDITOR set by Shell.editor = "EDITOR"
-  2. Looks for an EDITOR configured in your chef-shell config file
-  3. Uses the value of the EDITOR environment variable
+      explain(<<~E)
+        ## SUMMARY ##
+          +edit(object)+ allows you to edit any object that can be converted to JSON.
+          When finished editing, this method will return the edited object:
+
+              new_node = edit(existing_node)
+
+        ## EDITOR SELECTION ##
+          chef-shell looks for an editor using the following logic
+          1. Looks for an EDITOR set by Shell.editor = "EDITOR"
+          2. Looks for an EDITOR configured in your chef-shell config file
+          3. Uses the value of the EDITOR environment variable
       E
       def edit(object)
         unless Shell.editor
@@ -340,196 +340,196 @@ module Shell
       end
 
       desc "Find and edit API clients"
-      explain(<<-E)
-## SUMMARY ##
-  +clients+ allows you to query you chef server for information about your api
-  clients.
+      explain(<<~E)
+        ## SUMMARY ##
+          +clients+ allows you to query you chef server for information about your api
+          clients.
 
-## LIST ALL CLIENTS ##
-  To see all clients on the system, use
+        ## LIST ALL CLIENTS ##
+          To see all clients on the system, use
 
-      clients.all #=> [<Chef::ApiClient...>, ...]
+              clients.all #=> [<Chef::ApiClient...>, ...]
 
-  If the output from all is too verbose, or you're only interested in a specific
-  value from each of the objects, you can give a code block to +all+:
+          If the output from all is too verbose, or you're only interested in a specific
+          value from each of the objects, you can give a code block to +all+:
 
-      clients.all { |client| client.name } #=> [CLIENT1_NAME, CLIENT2_NAME, ...]
+              clients.all { |client| client.name } #=> [CLIENT1_NAME, CLIENT2_NAME, ...]
 
-## SHOW ONE CLIENT ##
-  To see a specific client, use
+        ## SHOW ONE CLIENT ##
+          To see a specific client, use
 
-      clients.show(CLIENT_NAME)
+              clients.show(CLIENT_NAME)
 
-## SEARCH FOR CLIENTS ##
-  You can also search for clients using +find+ or +search+. You can use the
-  familiar string search syntax:
+        ## SEARCH FOR CLIENTS ##
+          You can also search for clients using +find+ or +search+. You can use the
+          familiar string search syntax:
 
-      clients.search("KEY:VALUE")
+              clients.search("KEY:VALUE")
 
-  Just as the +all+ subcommand, the +search+ subcommand can use a code block to
-  filter or transform the information returned from the search:
+          Just as the +all+ subcommand, the +search+ subcommand can use a code block to
+          filter or transform the information returned from the search:
 
-      clients.search("KEY:VALUE") { |c| c.name }
+              clients.search("KEY:VALUE") { |c| c.name }
 
-  You can also use a Hash based syntax, multiple search conditions will be
-  joined with AND.
+          You can also use a Hash based syntax, multiple search conditions will be
+          joined with AND.
 
-      clients.find :KEY => :VALUE, :KEY2 => :VALUE2, ...
+              clients.find :KEY => :VALUE, :KEY2 => :VALUE2, ...
 
-## BULK-EDIT CLIENTS ##
-                    **BE CAREFUL, THIS IS DESTRUCTIVE**
-  You can bulk edit API Clients using the +transform+ subcommand, which requires
-  a code block. Each client will be saved after the code block is run. If the
-  code block returns +nil+ or +false+, that client will be skipped:
+        ## BULK-EDIT CLIENTS ##
+                            **BE CAREFUL, THIS IS DESTRUCTIVE**
+          You can bulk edit API Clients using the +transform+ subcommand, which requires
+          a code block. Each client will be saved after the code block is run. If the
+          code block returns +nil+ or +false+, that client will be skipped:
 
-      clients.transform("*:*") do |client|
-        if client.name =~ /borat/i
-          client.admin(false)
-          true
-        else
-          nil
-        end
-      end
+              clients.transform("*:*") do |client|
+                if client.name =~ /borat/i
+                  client.admin(false)
+                  true
+                else
+                  nil
+                end
+              end
 
-  This will strip the admin privileges from any client named after borat.
+          This will strip the admin privileges from any client named after borat.
       E
-      subcommands :all        => "list all api clients",
-                  :show       => "load an api client by name",
-                  :search     => "search for API clients",
-                  :transform  => "edit all api clients via a code block and save them"
+      subcommands all: "list all api clients",
+                  show: "load an api client by name",
+                  search: "search for API clients",
+                  transform: "edit all api clients via a code block and save them"
       def clients
         @clients ||= Shell::ModelWrapper.new(Chef::ApiClient, :client)
       end
 
       desc "Find and edit cookbooks"
-      subcommands :all        => "list all cookbooks",
-                  :show       => "load a cookbook by name",
-                  :transform  => "edit all cookbooks via a code block and save them"
+      subcommands all: "list all cookbooks",
+                  show: "load a cookbook by name",
+                  transform: "edit all cookbooks via a code block and save them"
       def cookbooks
         @cookbooks ||= Shell::ModelWrapper.new(Chef::CookbookVersion)
       end
 
       desc "Find and edit nodes via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +nodes+ Allows you to query your chef server for information about your nodes.
+      explain(<<~E)
+        ## SUMMARY ##
+          +nodes+ Allows you to query your chef server for information about your nodes.
 
-## LIST ALL NODES ##
-  You can list all nodes using +all+ or +list+
+        ## LIST ALL NODES ##
+          You can list all nodes using +all+ or +list+
 
-      nodes.all #=> [<Chef::Node...>, <Chef::Node...>, ...]
+              nodes.all #=> [<Chef::Node...>, <Chef::Node...>, ...]
 
-  To limit the information returned for each node, pass a code block to the +all+
-  subcommand:
+          To limit the information returned for each node, pass a code block to the +all+
+          subcommand:
 
-      nodes.all { |node| node.name } #=> [NODE1_NAME, NODE2_NAME, ...]
+              nodes.all { |node| node.name } #=> [NODE1_NAME, NODE2_NAME, ...]
 
-## SHOW ONE NODE ##
-  You can show the data for a single node using the +show+ subcommand:
+        ## SHOW ONE NODE ##
+          You can show the data for a single node using the +show+ subcommand:
 
-      nodes.show("NODE_NAME") => <Chef::Node @name="NODE_NAME" ...>
+              nodes.show("NODE_NAME") => <Chef::Node @name="NODE_NAME" ...>
 
-## SEARCH FOR NODES ##
-  You can search for nodes using the +search+ or +find+ subcommands:
+        ## SEARCH FOR NODES ##
+          You can search for nodes using the +search+ or +find+ subcommands:
 
-      nodes.find(:name => "app*") #=> [<Chef::Node @name="app1.example.com" ...>, ...]
+              nodes.find(:name => "app*") #=> [<Chef::Node @name="app1.example.com" ...>, ...]
 
-  Similarly to +all+, you can pass a code block to limit or transform the
-  information returned:
+          Similarly to +all+, you can pass a code block to limit or transform the
+          information returned:
 
-      nodes.find(:name => "app#") { |node| node.ec2 }
+              nodes.find(:name => "app#") { |node| node.ec2 }
 
-## BULK EDIT NODES ##
-              **BE CAREFUL, THIS OPERATION IS DESTRUCTIVE**
+        ## BULK EDIT NODES ##
+                      **BE CAREFUL, THIS OPERATION IS DESTRUCTIVE**
 
-  Bulk edit nodes by passing a code block to the +transform+ or +bulk_edit+
-  subcommand. The block will be applied to each matching node, and then the node
-  will be saved. If the block returns +nil+ or +false+, that node will be
-  skipped.
+          Bulk edit nodes by passing a code block to the +transform+ or +bulk_edit+
+          subcommand. The block will be applied to each matching node, and then the node
+          will be saved. If the block returns +nil+ or +false+, that node will be
+          skipped.
 
-      nodes.transform do |node|
-        if node.fqdn =~ /.*\\.preprod\\.example\\.com/
-          node.set[:environment] = "preprod"
-        end
-      end
+              nodes.transform do |node|
+                if node.fqdn =~ /.*\\.preprod\\.example\\.com/
+                  node.set[:environment] = "preprod"
+                end
+              end
 
-  This will assign the attribute to every node with a FQDN matching the regex.
+          This will assign the attribute to every node with a FQDN matching the regex.
       E
-      subcommands :all        => "list all nodes",
-                  :show       => "load a node by name",
-                  :search     => "search for nodes",
-                  :transform  => "edit all nodes via a code block and save them"
+      subcommands all: "list all nodes",
+                  show: "load a node by name",
+                  search: "search for nodes",
+                  transform: "edit all nodes via a code block and save them"
       def nodes
         @nodes ||= Shell::ModelWrapper.new(Chef::Node)
       end
 
       desc "Find and edit roles via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +roles+ allows you to query and edit roles on your Chef server.
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
+      explain(<<~E)
+        ## SUMMARY ##
+          +roles+ allows you to query and edit roles on your Chef server.
+
+        ## SUBCOMMANDS ##
+          * all       (list)
+          * show      (load)
+          * search    (find)
+          * transform (bulk_edit)
+
+        ## SEE ALSO ##
+          See the help for +nodes+ for more information about the subcommands.
       E
-      subcommands :all        => "list all roles",
-                  :show       => "load a role by name",
-                  :search     => "search for roles",
-                  :transform  => "edit all roles via a code block and save them"
+      subcommands all: "list all roles",
+                  show: "load a role by name",
+                  search: "search for roles",
+                  transform: "edit all roles via a code block and save them"
       def roles
         @roles ||= Shell::ModelWrapper.new(Chef::Role)
       end
 
       desc "Find and edit +databag_name+ via the api"
-      explain(<<-E)
-## SUMMARY ##
-  +databags(DATABAG_NAME)+ allows you to query and edit data bag items on your
-  Chef server. Unlike other commands for working with data on the server,
-  +databags+ requires the databag name as an argument, for example:
-    databags(:users).all
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
+      explain(<<~E)
+        ## SUMMARY ##
+          +databags(DATABAG_NAME)+ allows you to query and edit data bag items on your
+          Chef server. Unlike other commands for working with data on the server,
+          +databags+ requires the databag name as an argument, for example:
+            databags(:users).all
+
+        ## SUBCOMMANDS ##
+          * all       (list)
+          * show      (load)
+          * search    (find)
+          * transform (bulk_edit)
+
+        ## SEE ALSO ##
+          See the help for +nodes+ for more information about the subcommands.
 
       E
-      subcommands :all        => "list all items in the data bag",
-                  :show       => "load a data bag item by id",
-                  :search     => "search for items in the data bag",
-                  :transform  => "edit all items via a code block and save them"
+      subcommands all: "list all items in the data bag",
+                  show: "load a data bag item by id",
+                  search: "search for items in the data bag",
+                  transform: "edit all items via a code block and save them"
       def databags(databag_name)
         @named_databags_wrappers ||= {}
         @named_databags_wrappers[databag_name] ||= Shell::NamedDataBagWrapper.new(databag_name)
       end
 
       desc "Find and edit environments via the API"
-      explain(<<-E)
-## SUMMARY ##
-  +environments+ allows you to query and edit environments on your Chef server.
-
-## SUBCOMMANDS ##
-  * all       (list)
-  * show      (load)
-  * search    (find)
-  * transform (bulk_edit)
-
-## SEE ALSO ##
-  See the help for +nodes+ for more information about the subcommands.
+      explain(<<~E)
+        ## SUMMARY ##
+          +environments+ allows you to query and edit environments on your Chef server.
+
+        ## SUBCOMMANDS ##
+          * all       (list)
+          * show      (load)
+          * search    (find)
+          * transform (bulk_edit)
+
+        ## SEE ALSO ##
+          See the help for +nodes+ for more information about the subcommands.
       E
-      subcommands :all        => "list all environments",
-                  :show       => "load an environment by name",
-                  :search     => "search for environments",
-                  :transform  => "edit all environments via a code block and save them"
+      subcommands all: "list all environments",
+                  show: "load an environment by name",
+                  search: "search for environments",
+                  transform: "edit all environments via a code block and save them"
       def environments
         @environments ||= Shell::ModelWrapper.new(Chef::Environment)
       end