Merge pull request #8792 from joshcooper/array_concat

(PUP-11318) Use flat_map not +

Author: joshcooper

benchmarks/many_modules/benchmarker.rb

@@ -70,13 +70,24 @@ def generate
           )
       end
 
+      roles = 0.upto(10).to_a
+
       render(File.join(templates, 'module', 'init.pp.erb'),
              File.join(manifests, 'init.pp'),
-             :name => module_name)
+             :name => module_name,
+             :roles => roles
+            )
 
       render(File.join(templates, 'module', 'internal.pp.erb'),
              File.join(manifests, 'internal.pp'),
              :name => module_name)
+
+      roles.each do |j|
+        render(File.join(templates, 'module', 'role.pp.erb'),
+               File.join(manifests, "role#{j}.pp"),
+               :name => module_name,
+               :index => j)
+      end
     end
 
     render(File.join(templates, 'puppet.conf.erb'),

benchmarks/many_modules/module/init.pp.erb

@@ -1,3 +1,6 @@
 class <%= name %> {
   class { "<%= name %>::internal": }
+  <% roles.each do |role| %>
+    class { "<%= name %>::role<%= role %>": }
+  <% end %>
 }

benchmarks/many_modules/module/role.pp.erb

@@ -0,0 +1,3 @@
+class <%= name %>::role<%= index %> {
+  notify { "<%= name %>::role<%= index %>": }
+}

lib/puppet/pops/parser/code_merger.rb

@@ -11,17 +11,17 @@ def concatenate(parse_results)
     # PUP-5299, some sites have thousands of entries, and run out of stack when evaluating - the logic
     # below maps the logic as flatly as possible.
     #
-    children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
+    children = parse_results.select {|x| !x.nil? && x.code}.flat_map do |parsed_class|
       case parsed_class.code
       when Puppet::Parser::AST::BlockExpression
         # the BlockExpression wraps a single 4x instruction that is most likely wrapped in a Factory
-        memo + parsed_class.code.children.map {|c| c.is_a?(Puppet::Pops::Model::Factory) ? c.model : c }
+        parsed_class.code.children.map {|c| c.is_a?(Puppet::Pops::Model::Factory) ? c.model : c }
       when Puppet::Pops::Model::Factory
         # If it is a 4x instruction wrapped in a Factory
-        memo + parsed_class.code.model
+        parsed_class.code.model
       else
         # It is the instruction directly
-        memo << parsed_class.code
+        parsed_class.code
       end
     end
     Puppet::Parser::AST::BlockExpression.new(:children => children)