(PUP-11767) Enable Style/MapToHash

Author: tvpartytonight

.rubocop.yml

@@ -349,3 +349,6 @@ Style/LineEndConcatenation:
 
 Style/MapCompactWithConditionalBlock:
   Enabled: true
+
+Style/MapToHash:
+  Enabled: true

lib/puppet/context/trusted_information.rb

@@ -54,9 +54,9 @@ def self.remote(authenticated, node_name, certificate)
       if certificate.nil?
         Puppet.info(_('TrustedInformation expected a certificate, but none was given.'))
       else
-        extensions = certificate.custom_extensions.collect do |ext|
+        extensions = certificate.custom_extensions.to_h do |ext|
           [ext['oid'].freeze, ext['value'].freeze]
-        end.to_h
+        end
       end
       new('remote', node_name, extensions, external)
     else

lib/puppet/face/parser.rb

@@ -86,10 +86,10 @@
       unless errors.empty?
         ignore_error_keys = [:arguments, :environment, :node]
 
-        data = errors.map do |file, error|
+        data = errors.to_h do |file, error|
           file_errors = error.to_h.reject { |k, _| ignore_error_keys.include?(k) }
           [file, file_errors]
-        end.to_h
+        end
 
         puts Puppet::Util::Json.dump(Puppet::Pops::Serialization::ToDataConverter.convert(data, rich_data: false, symbol_as_string: true), :pretty => true)
 

lib/puppet/generate/models/type/type.rb

@@ -40,7 +40,7 @@ def initialize(type)
               Property.new(type.paramclass(name))
             end
             sc = Puppet::Pops::Types::StringConverter.singleton
-            @title_patterns = type.title_patterns.map do |mapping|
+            @title_patterns = type.title_patterns.to_h do |mapping|
               [
                 sc.convert(mapping[0], '%p'),
                 sc.convert(mapping[1].map do |names|
@@ -50,7 +50,7 @@ def initialize(type)
                   names[0].to_s
                 end, '%p')
               ]
-            end.to_h
+            end
             @isomorphic = type.isomorphic?
             # continue to emit capability as false when rendering the ERB
             # template, so that pcore modules generated prior to puppet7 can be

lib/puppet/network/http/api/server/v3/environments.rb

@@ -13,7 +13,6 @@ def initialize(env_loader)
                 @env_loader = env_loader
               end
 
-              # rubocop:disable Layout/MultilineMethodCallIndentation
               def call(request, response)
                 response
                   .respond_with(
@@ -22,7 +21,7 @@ def call(request, response)
                     Puppet::Util::Json
                       .dump({
                               "search_paths" => @env_loader.search_paths,
-                              "environments" => @env_loader.list.collect do |env|
+                              "environments" => @env_loader.list.to_h do |env|
                                 [env.name, {
                                   "settings" => {
                                     "modulepath" => env.full_modulepath,
@@ -31,11 +30,10 @@ def call(request, response)
                                     "config_version" => env.config_version || '',
                                   }
                                 }]
-                              end.to_h
+                              end
                             })
                   )
               end
-              # rubocop:enable Layout/MultilineMethodCallIndentation
 
               private
 

lib/puppet/node/environment.rb

@@ -379,7 +379,7 @@ def modules
 
   # @api private
   def modules_by_name
-    @modules_by_name ||= modules.map { |mod| [mod.name, mod] }.to_h
+    @modules_by_name ||= modules.to_h { |mod| [mod.name, mod] }
   end
   private :modules_by_name
 

lib/puppet/parser/scope.rb

@@ -260,7 +260,7 @@ def as_read_only
     end
 
     def to_hash
-      @params.select { |_, access| access.assigned? }.map { |name, access| [name, access.value] }.to_h
+      @params.select { |_, access| access.assigned? }.to_h { |name, access| [name, access.value] }
     end
   end
 

lib/puppet/pops/types/p_meta_type.rb

@@ -69,7 +69,7 @@ def resolve_hash(loader, init_hash)
   def resolve_type_refs(loader, o)
     case o
     when Hash
-      o.map { |k, v| [resolve_type_refs(loader, k), resolve_type_refs(loader, v)] }.to_h
+      o.to_h { |k, v| [resolve_type_refs(loader, k), resolve_type_refs(loader, v)] }
     when Array
       o.map { |e| resolve_type_refs(loader, e) }
     when PAnyType

lib/puppet/pops/types/p_object_type.rb

@@ -755,27 +755,27 @@ def _pcore_init_from_hash(init_hash)
     end
 
     unless attr_specs.empty?
-      @attributes = attr_specs.map do |key, attr_spec|
+      @attributes = attr_specs.to_h do |key, attr_spec|
         unless attr_spec.is_a?(Hash)
           attr_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
           attr_spec = { KEY_TYPE => attr_type }
           attr_spec[KEY_VALUE] = nil if attr_type.is_a?(POptionalType)
         end
         attr = PAttribute.new(key, self, attr_spec)
         [attr.name, attr.assert_override(parent_members)]
-      end.to_h.freeze
+      end.freeze
     end
 
     func_specs = init_hash[KEY_FUNCTIONS]
     unless func_specs.nil? || func_specs.empty?
-      @functions = func_specs.map do |key, func_spec|
+      @functions = func_specs.to_h do |key, func_spec|
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
         func = PFunction.new(key, self, func_spec)
         name = func.name
         raise Puppet::ParseError, _("%{label} conflicts with attribute with the same name") % { label: func.label } if @attributes.include?(name)
 
         [name, func.assert_override(parent_members)]
-      end.to_h.freeze
+      end.freeze
     end
 
     @equality_include_type = init_hash[KEY_EQUALITY_INCLUDE_TYPE]
@@ -1081,7 +1081,7 @@ def collect_equality_attributes(collector)
       # All attributes except constants participate
       collector.merge!(@attributes.reject { |_, attr| attr.kind == ATTRIBUTE_KIND_CONSTANT })
     else
-      collector.merge!(@equality.map { |attr_name| [attr_name, @attributes[attr_name]] }.to_h)
+      collector.merge!(@equality.to_h { |attr_name| [attr_name, @attributes[attr_name]] })
     end
     nil
   end
@@ -1098,14 +1098,14 @@ def collect_type_parameters(collector, include_parent)
   private
 
   def compressed_members_hash(features)
-    features.values.map do |feature|
+    features.values.to_h do |feature|
       fh = feature._pcore_init_hash
       if fh.size == 1
         type = fh[KEY_TYPE]
         fh = type unless type.nil?
       end
       [feature.name, fh]
-    end.to_h
+    end
   end
 
   # @return [PObjectType] the topmost parent who's #equality_attributes include the given _attr_

lib/puppet/pops/types/p_type_set_type.rb

@@ -183,7 +183,7 @@ def _pcore_init_hash
     result[KEY_NAME] = @name
     result[KEY_VERSION] = @version.to_s unless @version.nil?
     result[KEY_TYPES] = @types unless @types.empty?
-    result[KEY_REFERENCES] = @references.map { |ref_alias, ref| [ref_alias, ref._pcore_init_hash] }.to_h unless @references.empty?
+    result[KEY_REFERENCES] = @references.to_h { |ref_alias, ref| [ref_alias, ref._pcore_init_hash] } unless @references.empty?
     result
   end
 
@@ -328,11 +328,11 @@ def resolve_literal_hash(loader, init_hash_expression)
 
   # @api private
   def resolve_hash(loader, init_hash)
-    result = init_hash.map do |key, value|
+    result = init_hash.to_h do |key, value|
       key = resolve_type_refs(loader, key)
       value = resolve_type_refs(loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
       [key, value]
-    end.to_h
+    end
     name_auth = resolve_name_authority(result, loader)
     types = result[KEY_TYPES]
     if types.is_a?(Hash)