simp-rake-helpers 5.25.0 → 6.0.0

data/lib/simp/rake/pupmod/helpers.rb

@@ -1,17 +1,19 @@
-require 'puppetlabs_spec_helper/rake_tasks'
+# frozen_string_literal: true
+
+require 'voxpupuli/test/rake'
+require 'metadata-json-lint/rake_task'
 require 'puppet/version'
 require 'puppet-syntax/tasks/puppet-syntax'
 require 'puppet-lint/tasks/puppet-lint'
-require 'simp/rake/ci'
 require 'simp/rake/pkg'
 require 'simp/rake/beaker'
 require 'parallel_tests/cli'
 require 'simp/rake/fixtures'
 
 if Puppet.version.to_f >= 4.9
-    require 'semantic_puppet'
+  require 'semantic_puppet'
 elsif Puppet.version.to_f >= 3.6 && Puppet.version.to_f < 4.9
-    require 'puppet/vendor/semantic/lib/semantic'
+  require 'puppet/vendor/semantic/lib/semantic'
 end
 
 module Simp; end
@@ -21,33 +23,32 @@ module Simp::Rake::Pupmod; end
 # From http://dan.doezema.com/2012/04/recursively-sort-ruby-hash-by-key/
 class Hash
   def sort_by_key(recursive = false, &block)
-    self.keys.sort(&block).reduce({}) do |seed, key|
+    keys.sort(&block).each_with_object({}) do |key, seed|
       seed[key] = self[key]
       if recursive && seed[key].is_a?(Hash)
         seed[key] = seed[key].sort_by_key(true, &block)
       end
-      seed
     end
   end
 end
 
 # Rake tasks for SIMP Puppet modules
-class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
+class Simp::Rake::Pupmod::Helpers < Rake::TaskLib
   # See https://fedoraproject.org/wiki/Packaging:Guidelines?rd=Packaging/Guidelines#Changelogs
-  CHANGELOG_ENTRY_REGEX = /^\*\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{1,2} \d{4})\s+(.+<.+>)(?:\s+|\s*-\s*)?(\d+\.\d+\.\d+)/
+  CHANGELOG_ENTRY_REGEX = %r{^\*\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{1,2} \d{4})\s+(.+<.+>)(?:\s+|\s*-\s*)?(\d+\.\d+\.\d+)}.freeze
 
-  def initialize( base_dir = Dir.pwd )
+  def initialize(base_dir = Dir.pwd)
     @base_dir = base_dir
-    @temp_fixtures_path = File.join(base_dir,'spec','fixtures','simp_rspec')
+    @temp_fixtures_path = File.join(base_dir, 'spec', 'fixtures', 'simp_rspec')
 
     FileUtils.mkdir_p(@temp_fixtures_path)
 
-    Dir[ File.join(File.dirname(__FILE__),'*.rb') ].each do |rake_file|
+    Dir[File.join(File.dirname(__FILE__), '*.rb')].sort.each do |rake_file|
       next if rake_file == __FILE__
+
       require rake_file
     end
     define_tasks
-
   end
 
   def define_tasks
@@ -56,18 +57,18 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
     begin
       require 'puppet_blacksmith/rake_tasks'
       Blacksmith::RakeTask.new do |t|
-        t.tag_pattern = "%s" # Use tag format "X.Y.Z" instead of "vX.Y.Z"
+        t.tag_pattern = '%s' # Use tag format "X.Y.Z" instead of "vX.Y.Z"
       end
     rescue LoadError
     end
 
     # Lint & Syntax exclusions
     exclude_paths = [
-      "bundle/**/*",
-      "pkg/**/*",
-      "dist/**/*",
-      "vendor/**/*",
-      "spec/**/*",
+      'bundle/**/*',
+      'pkg/**/*',
+      'dist/**/*',
+      'vendor/**/*',
+      'spec/**/*',
     ]
     PuppetSyntax.exclude_paths = exclude_paths
 
@@ -78,18 +79,16 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       config.ignore_paths = PuppetLint.configuration.ignore_paths
     end
 
-    Simp::Rake::Fixtures.new( @base_dir )
+    Simp::Rake::Fixtures.new(@base_dir)
 
-    Simp::Rake::Pkg.new( @base_dir ) do | t |
+    Simp::Rake::Pkg.new(@base_dir) do |t|
       t.clean_list << "#{t.base_dir}/spec/fixtures/hieradata/hiera.yaml"
       t.clean_list << @temp_fixtures_path
     end
 
-    Simp::Rake::Beaker.new( @base_dir )
+    Simp::Rake::Beaker.new(@base_dir)
 
-    Simp::Rake::Ci.new( @base_dir )
-
-    desc "Run acceptance tests"
+    desc 'Run acceptance tests'
     RSpec::Core::RakeTask.new(:acceptance) do |t|
       t.pattern = 'spec/acceptance'
     end
@@ -100,17 +99,17 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
     end
 
     desc 'lint metadata.json'
-    Rake::Task[:metadata].clear if Rake::Task.tasks.any?{ |x| x.name == 'metadata' }
+    Rake::Task[:metadata].clear if Rake::Task.tasks.any? { |x| x.name == 'metadata' }
     task :metadata => :metadata_lint
 
     # Read the metadata.json as a data structure
-    def metadata( file_path = nil )
+    def metadata(file_path = nil)
       require 'json'
       _file = file_path || File.join(@base_dir, 'metadata.json')
-      fail "ERROR: file not found: '#{_file}'" unless File.exist? _file
-      @metadata ||= JSON.parse( File.read(_file) )
-    end
+      raise "ERROR: file not found: '#{_file}'" unless File.exist? _file
 
+      @metadata ||= JSON.parse(File.read(_file))
+    end
 
     # Generate an appropriate annotated tag entry from the modules' CHANGELOG
     #
@@ -121,23 +120,23 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
     #       4.0.0-2
     #       - Improved test stubs.
     #
-    def changelog_annotation( quiet = false, file = nil )
-      result         = ""
+    def changelog_annotation(quiet = false, file = nil)
+      result         = ''
       changelog_file = file || File.join(@base_dir, 'CHANGELOG')
       module_version = metadata['version']
-      changelogs      = {}
+      changelogs = {}
 
       _entry = {} # current log entry's metadata (empty unless valid entry)
       File.read(changelog_file).each_line do |line|
-        if line =~ /^\*/
+        if line =~ %r{^\*}
           if CHANGELOG_ENTRY_REGEX.match(line).nil?
-             warn %Q[WARNING: invalid changelogs entry: "#{line}"] unless quiet
-             _entry = {}
+            warn %(WARNING: invalid changelogs entry: "#{line}") unless quiet
+            _entry = {}
           else
             _entry = {
-              :date    => $1,
-              :user    => $2,
-              :release => $3,
+              :date => ::Regexp.last_match(1),
+              :user => ::Regexp.last_match(2),
+              :release => ::Regexp.last_match(3)
             }
             changelogs[_entry[:release]] ||= []
             changelogs[_entry[:release]] << line
@@ -149,29 +148,29 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
         changelogs[_entry[:release]] << "  #{line}" if _entry.fetch(:release, false)
       end
 
-      fail "Did not find any changelogs entries for version #{module_version}" if changelogs[module_version].nil?
+      raise "Did not find any changelogs entries for version #{module_version}" if changelogs[module_version].nil?
 
       result += "\nRelease of #{module_version}\n\n"
-      result += changelogs[module_version].join
+      result + changelogs[module_version].join
     end
 
     def custom_fixtures_hook(opts = {
-      :short_name          => nil,
-      :puppetfile          => nil,
-      :modulepath          => nil,
-      :local_fixtures_mods => nil,
+      :short_name => nil,
+      :puppetfile => nil,
+      :modulepath => nil,
+      :local_fixtures_mods => nil
     })
       short_name          = opts[:short_name]
       puppetfile          = opts[:puppetfile]
       modulepath          = opts[:modulepath]
       local_fixtures_mods = opts[:local_fixtures_mods] || []
 
-      fail('You must pass a short module name') unless short_name
+      raise('You must pass a short module name') unless short_name
 
       fixtures_hash = {
         'fixtures' => {
           'symlinks' => {
-            short_name => '#{source_dir}'
+            short_name => source_dir.to_s
           }
         }
       }
@@ -180,20 +179,20 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
 
       if modulepath
         unless File.directory?(modulepath)
-          fail("Could not find a module directory at #{modulepath}")
+          raise("Could not find a module directory at #{modulepath}")
         end
 
         # Grab all of the local modules and convert them into something
         # that can be turned into a Hash easily
-        local_modules = Hash[Dir.glob(File.join(modulepath, '*', 'metadata.json')).map do |m|
+        local_modules = Dir.glob(File.join(modulepath, '*', 'metadata.json')).to_h do |m|
           [File.basename(File.dirname(m)), File.absolute_path(File.dirname(m))]
-        end]
+        end
 
         local_modules.delete(short_name)
       end
 
       if puppetfile
-        fail("Could not find Puppetfile at #{puppetfile}") unless File.exist?(puppetfile)
+        raise("Could not find Puppetfile at #{puppetfile}") unless File.exist?(puppetfile)
 
         require 'simp/rake/build/deps'
 
@@ -223,7 +222,7 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
 
             fixtures_hash['fixtures']['repositories'][pupmod[:name]] = {
               'repo' => pupmod[:remote],
-              'ref'  => pupmod[:desired_ref]
+              'ref' => pupmod[:desired_ref]
             }
           end
         end
@@ -238,11 +237,11 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
         end
       end
 
-      if local_fixtures_mods.empty?
-        custom_fixtures_path = File.join(@temp_fixtures_path, 'fixtures.yml')
-      else
-        custom_fixtures_path = File.join(@temp_fixtures_path, 'fixtures_tmp.yml')
-      end
+      custom_fixtures_path = if local_fixtures_mods.empty?
+                               File.join(@temp_fixtures_path, 'fixtures.yml')
+                             else
+                               File.join(@temp_fixtures_path, 'fixtures_tmp.yml')
+                             end
 
       if puppetfile || modulepath
         File.open(custom_fixtures_path, 'w') do |fh|
@@ -254,15 +253,15 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
         errmsg = [
           '===',
           'The following modules in .fixtures.yml were not found in the Puppetfile:',
-          %{  * #{local_fixtures_mods.join("\n  * ")}},
-          %{A temporary fixtures file has been written to #{custom_fixtures_path}},
-          '==='
+          %(  * #{local_fixtures_mods.join("\n  * ")}),
+          %(A temporary fixtures file has been written to #{custom_fixtures_path}),
+          '===',
         ]
 
-        fail(errmsg.join("\n"))
+        raise(errmsg.join("\n"))
       end
 
-      return custom_fixtures_path
+      custom_fixtures_path
     end
 
     desc <<-EOM
@@ -289,10 +288,10 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
     #   `rpm -q --specfile dist/tmp/*.spec --changelog`
     # That will give Travis a way of warning us if the changelog
     # will prevent the rpm from building.
-    task :changelog_annotation, [:quiet] do |t,args|
+    task :changelog_annotation, [:quiet] do |_t, args|
       warn('DEPRECATED: use pkg:create_tag_changelog')
       quiet = true if args[:quiet].to_s == 'true'
-      puts changelog_annotation( quiet )
+      puts changelog_annotation(quiet)
     end
 
     desc <<-EOM
@@ -332,7 +331,7 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       - spec directory
       - doc directory
     EOM
-    task :compare_latest_tag, [:tags_source, :ignore_owner, :verbose] do |t,args|
+    task :compare_latest_tag, [:tags_source, :ignore_owner, :verbose] do |_t, args|
       warn('DEPRECATED: use pkg:compare_latest_tag')
       require 'json'
 
@@ -341,24 +340,24 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       verbose = true if args[:verbose].to_s == 'true'
 
       module_version = metadata['version']
-      owner =  metadata['name'].split('-')[0]
+      owner = metadata['name'].split('-')[0]
 
-      if (owner == 'simp') or ignore_owner
+      if (owner == 'simp') || ignore_owner
         # determine last tag
         `git fetch -t #{tags_source} 2>/dev/null`
         tags = `git tag -l`.split("\n")
         puts "Available tags from #{tags_source} = #{tags}" if verbose
-        tags.delete_if { |tag| tag.include?('-') or (tag =~ /^v/) }
+        tags.delete_if { |tag| tag.include?('-') or (tag =~ %r{^v}) }
 
         if tags.empty?
           puts "No tags exist from #{tags_source}"
         else
-          last_tag = (tags.sort { |a,b| Gem::Version.new(a) <=> Gem::Version.new(b) })[-1]
+          last_tag = tags.max { |a, b| Gem::Version.new(a) <=> Gem::Version.new(b) }
 
           # determine mission-impacting files that have changed
           files_changed = `git diff tags/#{last_tag} --name-only`.strip.split("\n")
           files_changed.delete_if do |file|
-            file[0] ==  '.' || file =~ /^Gemfile/ || file == 'Rakefile' || file =~/^spec\// || file =~/^doc\// || file =~/^rakelib\//
+            file[0] ==  '.' || file =~ %r{^Gemfile} || file == 'Rakefile' || file =~ %r{^spec/} || file =~ %r{^doc/} || file =~ %r{^rakelib/}
           end
 
           if files_changed.empty?
@@ -367,15 +366,15 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
             unless ignore_owner
               # determine latest version from CHANGELOG, which will present
               # for all SIMP Puppet modules
-              line = IO.readlines('CHANGELOG')[0]
-              match = line.match(/^\*\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{2} \d{4})\s+(.+<.+>)(?:\s+|\s*-\s*)?(\d+\.\d+\.\d+)/)
+              line = File.readlines('CHANGELOG')[0]
+              match = line.match(%r{^\*\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{2} \d{4})\s+(.+<.+>)(?:\s+|\s*-\s*)?(\d+\.\d+\.\d+)})
               unless match
-                fail("ERROR: Invalid CHANGELOG entry. Unable to extract version from '#{line}'")
+                raise("ERROR: Invalid CHANGELOG entry. Unable to extract version from '#{line}'")
               end
 
               changelog_version = match[3]
               unless module_version == changelog_version
-                fail("ERROR: Version mismatch.  module version=#{module_version}  changelog version=#{changelog_version}")
+                raise("ERROR: Version mismatch.  module version=#{module_version}  changelog version=#{changelog_version}")
               end
             end
 
@@ -383,9 +382,9 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
             last_tag_version = Gem::Version.new(last_tag)
 
             if curr_module_version < last_tag_version
-              fail("ERROR: Version regression. '#{module_version}' < last tag '#{last_tag}'")
+              raise("ERROR: Version regression. '#{module_version}' < last tag '#{last_tag}'")
             elsif curr_module_version == last_tag_version
-              fail("ERROR: Version update beyond last tag '#{last_tag}' is required for #{files_changed.count} changed files:\n  * #{files_changed.join("\n  * ")}")
+              raise("ERROR: Version update beyond last tag '#{last_tag}' is required for #{files_changed.count} changed files:\n  * #{files_changed.join("\n  * ")}")
             else
               puts "NOTICE: New tag of version '#{module_version}' is required for #{files_changed.count} changed files:\n  * #{files_changed.join("\n  * ")}"
             end
@@ -396,7 +395,7 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       end
     end
 
-    desc "Run syntax, lint, and spec tests."
+    desc 'Run syntax, lint, and spec tests.'
     task :test => [
       :syntax,
       :lint,
@@ -414,14 +413,28 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       if ENV['SIMP_PARALLEL_TARGETS']
         test_targets += ENV['SIMP_PARALLEL_TARGETS'].split
       end
-      test_targets.delete_if{|dir| !File.directory?(dir)}
-      Rake::Task[:spec_prep].invoke
+      test_targets.delete_if { |dir| !File.directory?(dir) }
+      Rake::Task['fixtures:prep'].invoke
       ParallelTests::CLI.new.run('--type test -t rspec'.split + test_targets)
       if ENV.fetch('SPEC_clean', 'no') == 'yes'
-        Rake::Task[:spec_clean].invoke
+        Rake::Task['fixtures:clean'].invoke
       end
     end
 
+    # Backwards-compatible aliases for the task names that
+    # puppetlabs_spec_helper provided before the migration to voxpupuli-test.
+    # voxpupuli-test/puppet_fixtures namespace these under fixtures:/spec:.
+    {
+      'spec_prep' => 'fixtures:prep',
+      'spec_clean' => 'fixtures:clean',
+      'spec_standalone' => 'spec:standalone'
+    }.each do |old_name, new_name|
+      next if Rake::Task.task_defined?(old_name)
+
+      desc "Alias for #{new_name}"
+      task old_name => new_name
+    end
+
     # This hidden task provides a way to create and use a fixtures.yml file
     # based on an externally specified Puppetfile
     #
@@ -453,8 +466,8 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
 
           puppetfile_tgt = File.join(@temp_fixtures_path, 'Puppetfile')
 
-          if puppetfile =~ %r{://}
-            %x{curl -k -s -o #{puppetfile_tgt} #{puppetfile}}
+          if puppetfile.include?('://')
+            `curl -k -s -o #{puppetfile_tgt} #{puppetfile}`
           else
             FileUtils.cp(File.absolute_path(puppetfile), puppetfile_tgt)
           end
@@ -468,13 +481,13 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
 
         if opts[:puppetfile] || opts[:modulepath]
           unless @custom_fixtures_hook_override_fixtures
-            fail("Could not find '.fixtures.yml' at #{Dir.pwd}") unless File.exist?('.fixtures.yml')
+            raise("Could not find '.fixtures.yml' at #{Dir.pwd}") unless File.exist?('.fixtures.yml')
 
             opts[:local_fixtures_mods] = []
 
             require 'yaml'
             _fixtures = YAML.load_file('.fixtures.yml')['fixtures']
-            _fixtures.keys.each do |subset|
+            _fixtures.each_key do |subset|
               _fixtures[subset].each_pair do |_mod, _extra|
                 opts[:local_fixtures_mods] << _mod
               end
@@ -490,10 +503,10 @@ class Simp::Rake::Pupmod::Helpers < ::Rake::TaskLib
       end
     end
 
-    Rake::Task['spec_prep'].enhance [:custom_fixtures_hook] do
-      Dir.glob(File.join('spec','fixtures','modules','*')).each do |dir|
-        if @custom_fixtures_hook_override_fixtures
-          FileUtils.remove_entry_secure(dir) unless File.exist?(File.join(dir, 'metadata.json'))
+    Rake::Task['fixtures:prep'].enhance [:custom_fixtures_hook] do
+      Dir.glob(File.join('spec', 'fixtures', 'modules', '*')).each do |dir|
+        if @custom_fixtures_hook_override_fixtures && !File.exist?(File.join(dir, 'metadata.json'))
+          FileUtils.remove_entry_secure(dir)
         end
       end
     end

data/lib/simp/rake/pupmod/module_build.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'puppet/modulebuilder'
+
+module Simp
+  module Rake
+    module Pupmod
+      # Extends Puppet::Modulebuilder::Builder to honour .pdkignore files.
+      # puppet-modulebuilder 2.x dropped native .pdkignore support; this
+      # restores it so the published tarball matches what PDK produced.
+      class PdkCompatBuilder < Puppet::Modulebuilder::Builder
+        def ignored_files
+          spec = super
+          pdkignore = File.join(source, '.pdkignore')
+          return spec unless File.exist?(pdkignore)
+
+          ignore = PathSpec.from_filename(pdkignore)
+          ignore.add('.*') # Ignore dotfiles by default
+          ignore
+        end
+      end
+    end
+  end
+end
+
+# Make the Rake DSL (namespace/desc/task) available so this file can be required
+# directly (e.g. from RSpec), not only from within a Rakefile where the DSL is
+# already mixed into the top-level scope.
+extend Rake::DSL
+
+namespace :pupmod do
+  desc 'Build the Puppet module package into pkg/, honouring .pdkignore'
+  task :build do
+    builder = Simp::Rake::Pupmod::PdkCompatBuilder.new(Dir.pwd)
+    pkg = builder.build
+    puts "Built: #{pkg}"
+  end
+end

data/lib/simp/rake/rubygem.rb

@@ -1,74 +1,75 @@
+# frozen_string_literal: true
+
 module Simp; end
-module Simp::Rake
-  class Rubygem < ::Rake::TaskLib
-    def initialize( package, rakefile_dir = File.pwd )
-      @package      = package
-      @rakefile_dir = rakefile_dir
-      define
-    end
 
-    def define_clean_paths
-      CLEAN.include "#{@package}-*.gem"
-      CLEAN.include 'pkg'
-      CLEAN.include 'dist'
-      CLEAN.include 'spec/acceptance/files/testpackage/dist'
-      Find.find( @rakefile_dir ) do |path|
-        if File.directory? path
-          CLEAN.include path if File.basename(path) == 'tmp'
-        else
-          Find.prune
-        end
+class Simp::Rake::Rubygem < Rake::TaskLib
+  def initialize(package, rakefile_dir = File.pwd)
+    @package      = package
+    @rakefile_dir = rakefile_dir
+    define
+  end
+
+  def define_clean_paths
+    CLEAN.include "#{@package}-*.gem"
+    CLEAN.include 'pkg'
+    CLEAN.include 'dist'
+    CLEAN.include 'spec/acceptance/files/testpackage/dist'
+    Find.find(@rakefile_dir) do |path|
+      if File.directory? path
+        CLEAN.include path if File.basename(path) == 'tmp'
+      else
+        Find.prune
       end
     end
+  end
 
-    def define
-      define_clean_paths
+  def define
+    define_clean_paths
 
-      desc 'Ensure gemspec-safe permissions on all files'
-      task :chmod do
-        gemspec = File.expand_path( "#{@package}.gemspec", @rakefile_dir ).strip
-        spec = Gem::Specification::load( gemspec )
-        spec.files.each do |file|
-          FileUtils.chmod 'go=r', file
-        end
+    desc 'Ensure gemspec-safe permissions on all files'
+    task :chmod do
+      gemspec = File.expand_path("#{@package}.gemspec", @rakefile_dir).strip
+      spec = Gem::Specification.load(gemspec)
+      spec.files.each do |file|
+        FileUtils.chmod 'go=r', file
       end
+    end
 
-      namespace :pkg do
-        desc "build rubygem package for #{@package}"
-        task :gem => :chmod do
-          Dir.chdir @rakefile_dir
-          Dir['*.gemspec'].each do |spec_file|
-            cmd = %Q{SIMP_RPM_BUILD=#{ENV.fetch('SIMP_RPM_BUILD',1)} bundle exec gem build "#{spec_file}"}
-            sh cmd
-            FileUtils.mkdir_p 'dist'
-            FileUtils.mv Dir.glob("#{@package}*.gem"), 'dist/'
-          end
+    namespace :pkg do
+      desc "build rubygem package for #{@package}"
+      task :gem => :chmod do
+        Dir.chdir @rakefile_dir
+        Dir['*.gemspec'].each do |spec_file|
+          cmd = %(SIMP_RPM_BUILD=#{ENV.fetch('SIMP_RPM_BUILD', 1)} bundle exec gem build "#{spec_file}")
+          sh cmd
+          FileUtils.mkdir_p 'dist'
+          FileUtils.mv Dir.glob("#{@package}*.gem"), 'dist/'
         end
+      end
 
-        desc "build and install rubygem package for #{@package}"
-        task :install_gem => [:clean, :gem] do
-          Dir.chdir @rakefile_dir
-          Dir.glob("dist/#{@package}*.gem") do |pkg|
-            if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-              sh %Q{bundle exec gem install --no-document #{pkg}}
-            else
-              sh %Q{bundle exec gem install --no-ri --no-rdoc #{pkg}}
-            end
+      desc "build and install rubygem package for #{@package}"
+      task :install_gem => [:clean, :gem] do
+        Dir.chdir @rakefile_dir
+        Dir.glob("dist/#{@package}*.gem") do |pkg|
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
+            sh %(bundle exec gem install --no-document #{pkg})
+          else
+            sh %(bundle exec gem install --no-ri --no-rdoc #{pkg})
           end
         end
       end
+    end
 
-      desc "Run acceptance tests"
-      RSpec::Core::RakeTask.new(:acceptance) do |t|
-        t.pattern = 'spec/acceptance'
-      end
+    desc 'Run acceptance tests'
+    RSpec::Core::RakeTask.new(:acceptance) do |t|
+      t.pattern = 'spec/acceptance'
+    end
 
-      desc "Run spec tests"
-      RSpec::Core::RakeTask.new(:spec) do |t|
-          t.rspec_opts = ['--color']
-          t.exclude_pattern = '**/{acceptance,fixtures,files}/**/*_spec.rb'
-          t.pattern = 'spec/lib/simp/**/*_spec.rb'
-      end
+    desc 'Run spec tests'
+    RSpec::Core::RakeTask.new(:spec) do |t|
+      t.rspec_opts = ['--color']
+      t.exclude_pattern = '**/{acceptance,fixtures,files}/**/*_spec.rb'
+      t.pattern = 'spec/lib/simp/**/*_spec.rb'
     end
   end
 end