sitemap_generator 6.3.0 → 7.1.1

data/lib/sitemap_generator/link_set.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 require 'builder'
 
 # A LinkSet provisions a bunch of links to sitemap files.  It also writes the index file
 # which lists all the sitemap files written.
 module SitemapGenerator
-  class LinkSet
-    @@requires_finalization_opts = [:filename, :sitemaps_path, :sitemaps_host, :namer]
-    @@new_location_opts = [:filename, :sitemaps_path, :namer]
+  # Top-level configuration and orchestration object for a sitemap generation run.
+  # Owns the adapter, host, paths, and namer; manages the lifecycle of sitemap files
+  # from creation through finalization. See +SitemapGenerator::Sitemap+ for the public API.
+  class LinkSet # rubocop:disable Metrics/ClassLength
+    REQUIRES_FINALIZATION_OPTS = %i[filename sitemaps_path sitemaps_host namer].freeze
+    NEW_LOCATION_OPTS = %i[filename sitemaps_path namer].freeze
 
     attr_reader :default_host, :sitemaps_path, :filename, :create_index
     attr_accessor :include_root, :include_index, :adapter, :yield_sitemap, :max_sitemap_links
@@ -30,17 +35,17 @@ module SitemapGenerator
     # If you are calling +create+ more than once in your sitemap configuration file,
     # make sure that you set a different +sitemaps_path+ or +filename+ for each call otherwise
     # the sitemaps may be overwritten.
-    def create(opts={}, &block)
+    def create(opts = {}, &block) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       reset!
       set_options(opts)
       if verbose
         start_time = Time.now
         puts "In '#{sitemap_index.location.public_path}':"
       end
-      interpreter.eval(:yield_sitemap => yield_sitemap?, &block)
-      finalize!
+      interpreter.eval(yield_sitemap: yield_sitemap?, &block)
+      finalize! if block_given?
       end_time = Time.now if verbose
-      output(sitemap_index.stats_summary(:time_taken => end_time - start_time)) if verbose
+      output(sitemap_index.stats_summary(time_taken: end_time - start_time)) if verbose
       self
     end
 
@@ -117,27 +122,26 @@ module SitemapGenerator
     #
     # Note: When adding a new option be sure to include it in `options_for_group()` if
     # the option should be inherited by groups.
-    def initialize(options={})
-      @default_host, @sitemaps_host, @yield_sitemap, @sitemaps_path, @adapter, @verbose, @protect_index, @sitemap_index, @added_default_links, @created_group, @sitemap = nil
+    def initialize(options = {}) # rubocop:disable Metrics/MethodLength
+      @default_host, @sitemaps_host, @yield_sitemap, @sitemaps_path,
+      @adapter, @verbose, @protect_index, @sitemap_index,
+      @added_default_links, @created_group, @sitemap = nil
 
       options = SitemapGenerator::Utilities.reverse_merge(options,
-        :include_root => true,
-        :include_index => false,
-        :filename => :sitemap,
-        :search_engines => {
-          :google         => "http://www.google.com/webmasters/tools/ping?sitemap=%s"
-        },
-        :create_index => :auto,
-        :compress => true,
-        :max_sitemap_links => SitemapGenerator::MAX_SITEMAP_LINKS
-      )
-      options.each_pair { |k, v| instance_variable_set("@#{k}".to_sym, v) }
+                                                          include_root: true,
+                                                          include_index: false,
+                                                          filename: :sitemap,
+                                                          search_engines: {},
+                                                          create_index: :auto,
+                                                          compress: true,
+                                                          max_sitemap_links: SitemapGenerator::MAX_SITEMAP_LINKS)
+      options.each_pair { |k, v| instance_variable_set(:"@#{k}", v) }
 
       # If an index is passed in, protect it from modification.
       # Sitemaps can be added to the index but nothing else can be changed.
-      if options[:sitemap_index]
-        @protect_index = true
-      end
+      return unless options[:sitemap_index]
+
+      @protect_index = true
     end
 
     # Add a link to a Sitemap.  If a new Sitemap is required, one will be created for
@@ -146,9 +150,9 @@ module SitemapGenerator
     # link - string link e.g. '/merchant', '/article/1' or whatever.
     # options - see README.
     #   host - host for the link, defaults to your <tt>default_host</tt>.
-    def add(link, options={})
-      add_default_links if !@added_default_links
-      sitemap.add(link, SitemapGenerator::Utilities.reverse_merge(options, :host => @default_host))
+    def add(link, options = {})
+      add_default_links unless @added_default_links
+      sitemap.add(link, SitemapGenerator::Utilities.reverse_merge(options, host: @default_host))
     rescue SitemapGenerator::SitemapFullError
       finalize_sitemap!
       retry
@@ -163,8 +167,8 @@ module SitemapGenerator
     #
     # The `:host` option defaults to the value of `sitemaps_host` which is the host where your
     # sitemaps reside.  If no `sitemaps_host` is set, the `default_host` is used.
-    def add_to_index(link, options={})
-      sitemap_index.add(link, SitemapGenerator::Utilities.reverse_merge(options, :host => sitemaps_host))
+    def add_to_index(link, options = {})
+      sitemap_index.add(link, SitemapGenerator::Utilities.reverse_merge(options, host: sitemaps_host))
     end
 
     # Create a new group of sitemap files.
@@ -194,15 +198,15 @@ module SitemapGenerator
     # Options like <tt>:default_host</tt> can be used and it will only affect the links
     # within the group.  Links added outside of the group will revert to the previous
     # +default_host+.
-    def group(opts={}, &block)
+    def group(opts = {}, &block) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       @created_group = true
       original_opts = opts.dup
 
-      if (@@requires_finalization_opts & original_opts.keys).empty?
+      if (REQUIRES_FINALIZATION_OPTS & original_opts.keys).empty?
         # If no new filename or path is specified reuse the default sitemap file.
         # A new location object will be set on it for the duration of the group.
         original_opts[:sitemap] = sitemap
-      elsif original_opts.key?(:sitemaps_host) && (@@new_location_opts & original_opts.keys).empty?
+      elsif original_opts.key?(:sitemaps_host) && (NEW_LOCATION_OPTS & original_opts.keys).empty?
         # If no location options are provided we are creating the next sitemap in the
         # current series, so finalize and inherit the namer.
         finalize_sitemap!
@@ -217,7 +221,7 @@ module SitemapGenerator
         @original_location = @sitemap.location.dup
         @sitemap.location.merge!(@group.sitemap_location)
         if block_given?
-          @group.interpreter.eval(:yield_sitemap => @yield_sitemap || SitemapGenerator.yield_sitemap?, &block)
+          @group.interpreter.eval(yield_sitemap: @yield_sitemap || SitemapGenerator.yield_sitemap?, &block)
           @group.finalize_sitemap!
           @sitemap.location.merge!(@original_location)
         end
@@ -236,7 +240,7 @@ module SitemapGenerator
         @group.send(:create_index=, true, true) if @group.create_index != false
 
         if block_given?
-          @group.interpreter.eval(:yield_sitemap => @yield_sitemap || SitemapGenerator.yield_sitemap?, &block)
+          @group.interpreter.eval(yield_sitemap: @yield_sitemap || SitemapGenerator.yield_sitemap?, &block)
           @group.finalize_sitemap!
         end
       end
@@ -278,30 +282,26 @@ module SitemapGenerator
     # Is equivalent to:
     #
     #   SitemapGenerator::Sitemap.ping_search_engines('http://example.com/sitemap.xml.gz', :super_engine => 'http://superengine.com/ping?url=%s')
-    def ping_search_engines(*args)
-      require 'cgi/session'
+    def ping_search_engines(*args) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       require 'open-uri'
       require 'timeout'
+      require 'uri'
 
       engines = args.last.is_a?(Hash) ? args.pop : {}
       unescaped_url = args.shift || sitemap_index_url
-      index_url = CGI.escape(unescaped_url)
+      index_url = URI.encode_www_form_component(unescaped_url)
 
       output("\n")
       output("Pinging with URL '#{unescaped_url}':")
       search_engines.merge(engines).each do |engine, link|
-        link = link % index_url
+        link %= index_url
         name = Utilities.titleize(engine.to_s)
         begin
-          Timeout::timeout(10) {
-            if URI.respond_to?(:open) # Available since Ruby 2.5
-              URI.open(link)
-            else
-              open(link) # using Kernel#open became deprecated since Ruby 2.7. See https://bugs.ruby-lang.org/issues/15893
-            end
-          }
+          Timeout.timeout(10) do
+            URI.open(link) # rubocop:disable Security/Open
+          end
           output("  Successful ping of #{name}")
-        rescue Timeout::Error, StandardError => e
+        rescue StandardError => e
           output("Ping failed for #{name}: #{e.inspect} (URL #{link})")
         end
       end
@@ -366,9 +366,7 @@ module SitemapGenerator
     # By default verbose is true.  When running rake tasks, pass the <tt>-s</tt>
     # option to rake to turn verbose off.
     def verbose
-      if @verbose.nil?
-        @verbose = SitemapGenerator.verbose.nil? ? true : SitemapGenerator.verbose
-      end
+      @verbose = SitemapGenerator.verbose.nil? || SitemapGenerator.verbose if @verbose.nil?
       @verbose
     end
 
@@ -384,27 +382,26 @@ module SitemapGenerator
     #
     # If both `filename` and `namer` are passed, set filename first so it
     # doesn't override the latter.
-    def set_options(opts={})
+    def set_options(opts = {})
       opts = opts.dup
-      %w(filename namer).each do |key|
-        if value = opts.delete(key.to_sym)
-          send("#{key}=", value)
+      %w[filename namer].each do |key|
+        if (value = opts.delete(key.to_sym))
+          send(:"#{key}=", value)
         end
       end
       opts.each_pair do |key, value|
-        send("#{key}=", value)
+        send(:"#{key}=", value)
       end
     end
 
     # Given +opts+, modify it and return it prepped for creating a new group from this LinkSet.
     # If <tt>:public_path</tt> is present in +opts+ it is removed because groups cannot
     # change the public path.
-    def options_for_group(opts)
+    def options_for_group(opts) # rubocop:disable Metrics/MethodLength
       opts = SitemapGenerator::Utilities.reverse_merge(opts,
-        :include_index => false,
-        :include_root => false,
-        :sitemap_index => sitemap_index
-      )
+                                                       include_index: false,
+                                                       include_root: false,
+                                                       sitemap_index: sitemap_index)
       opts.delete(:public_path)
 
       # Reverse merge the current settings.
@@ -412,22 +409,21 @@ module SitemapGenerator
       # This hash could be a problem because it needs to be maintained
       # when new options are added, but can easily be missed.  We really could
       # do with a separate SitemapOptions class.
-      current_settings = [
-        :include_root,
-        :include_index,
-        :sitemaps_path,
-        :public_path,
-        :sitemaps_host,
-        :verbose,
-        :default_host,
-        :adapter,
-        :create_index,
-        :compress,
-        :max_sitemap_links
-      ].inject({}) do |hash, key|
+      current_settings = %i[
+        include_root
+        include_index
+        sitemaps_path
+        public_path
+        sitemaps_host
+        verbose
+        default_host
+        adapter
+        create_index
+        compress
+        max_sitemap_links
+      ].each_with_object({}) do |key, hash|
         value = instance_variable_get(:"@#{key}")
         hash[key] = value unless value.nil?
-        hash
       end
       SitemapGenerator::Utilities.reverse_merge!(opts, current_settings)
       opts
@@ -437,13 +433,11 @@ module SitemapGenerator
     # in an instance variable.
     def add_default_links
       @added_default_links = true
-      link_options = { :lastmod => Time.now, :priority => 1.0 }
-      if include_root?
-        add('/', link_options)
-      end
-      if include_index?
-        add(sitemap_index, link_options)
-      end
+      link_options = { priority: 1.0, lastmod: SitemapGenerator::Utilities.current_time }
+      add('/', link_options) if include_root?
+      return unless include_index?
+
+      add(sitemap_index, link_options)
     end
 
     # Finalize a sitemap by including it in the index and outputting a summary line.
@@ -457,7 +451,8 @@ module SitemapGenerator
     # block passed to create() is empty the default links are still included in the
     # sitemap.
     def finalize_sitemap!
-      return if sitemap.finalized? || sitemap.empty? && @created_group
+      return if sitemap.finalized? || (sitemap.empty? && @created_group)
+
       add_default_links if !@added_default_links && !@created_group
       # This will finalize it.  We add to the index even if not creating an index because
       # the index keeps track of how many links are in our sitemaps and we need this info
@@ -470,6 +465,7 @@ module SitemapGenerator
     # been finalized.
     def finalize_sitemap_index!
       return if @protect_index || sitemap_index.finalized?
+
       sitemap_index.finalize!
       sitemap_index.write
     end
@@ -477,15 +473,15 @@ module SitemapGenerator
     # Return the interpreter linked to this instance.
     def interpreter
       require 'sitemap_generator/interpreter'
-      @interpreter ||= SitemapGenerator::Interpreter.new(:link_set => self)
+      @interpreter ||= SitemapGenerator::Interpreter.new(link_set: self)
     end
 
     # Reset this instance.  Keep the same options, but return to the same state
     # as before any sitemaps were created.
     def reset!
-      @sitemap_index = nil if @sitemap_index && @sitemap_index.finalized? && !@protect_index
-      @sitemap = nil if @sitemap && @sitemap.finalized?
-      self.namer.reset
+      @sitemap_index = nil if @sitemap_index&.finalized? && !@protect_index
+      @sitemap = nil if @sitemap&.finalized?
+      namer.reset
       @added_default_links = false
     end
 
@@ -493,12 +489,13 @@ module SitemapGenerator
     # evaluated and some info output to STDOUT in a lazy fasion.
     def output(string)
       return unless verbose
+
       puts string
     end
 
+    # Setters that propagate location configuration (host, paths, adapter) to the
+    # active sitemap and index files whenever a value changes on the LinkSet.
     module LocationHelpers
-      public
-
       # Set the host name, including protocol, that will be used by default on each
       # of your sitemap links.  You can pass a different host in your options to `add`
       # if you need to change it on a per-link basis.
@@ -516,16 +513,14 @@ module SitemapGenerator
       # Set to nil to use the current directory.
       def public_path=(value)
         @public_path = Pathname.new(SitemapGenerator::Utilities.append_slash(value))
-        if @public_path.relative?
-          @public_path = SitemapGenerator.app.root + @public_path
-        end
+        @public_path = SitemapGenerator.app.root + @public_path if @public_path.relative?
         update_location_info(:public_path, @public_path)
-        @public_path
+        @public_path # rubocop:disable Lint/Void -- return value used by send(:public_path=) in the getter
       end
 
       # Return a Pathname with the full path to the public directory
       def public_path
-        @public_path ||= self.send(:public_path=, 'public/')
+        @public_path ||= send(:public_path=, 'public/')
       end
 
       # Set the sitemaps_path.  This path gives the location to write sitemaps to
@@ -576,28 +571,28 @@ module SitemapGenerator
       # Return a new +SitemapLocation+ instance with the current options included
       def sitemap_location
         SitemapGenerator::SitemapLocation.new(
-          :host => sitemaps_host,
-          :namer => namer,
-          :public_path => public_path,
-          :sitemaps_path => @sitemaps_path,
-          :adapter => @adapter,
-          :verbose => verbose,
-          :compress => @compress,
-          :max_sitemap_links => max_sitemap_links
+          host: sitemaps_host,
+          namer: namer,
+          public_path: public_path,
+          sitemaps_path: @sitemaps_path,
+          adapter: @adapter,
+          verbose: verbose,
+          compress: @compress,
+          max_sitemap_links: max_sitemap_links
         )
       end
 
       # Return a new +SitemapIndexLocation+ instance with the current options included
       def sitemap_index_location
         SitemapGenerator::SitemapLocation.new(
-          :host => sitemaps_host,
-          :namer => namer,
-          :public_path => public_path,
-          :sitemaps_path => @sitemaps_path,
-          :adapter => @adapter,
-          :verbose => verbose,
-          :create_index => @create_index,
-          :compress => @compress
+          host: sitemaps_host,
+          namer: namer,
+          public_path: public_path,
+          sitemaps_path: @sitemaps_path,
+          adapter: @adapter,
+          verbose: verbose,
+          create_index: @create_index,
+          compress: @compress
         )
       end
 
@@ -609,12 +604,15 @@ module SitemapGenerator
       # are in your sitemap.  If `false` an index file is never created.
       # If `:auto` an index file is created only if your sitemap has more than
       # one sitemap file.
-      def create_index=(value, force=false)
+      def create_index=(value, force = false) # rubocop:disable Style/OptionalBooleanParameter
         @create_index = value
         # Allow overriding the protected status of the index when we are creating a group.
         # Because sometimes we need to force an index in that case.  But generally we don't
         # want to allow people to mess with this value if the index is protected.
-        @sitemap_index.location[:create_index] = value if @sitemap_index && ((!@sitemap_index.finalized? && !@protect_index) || force)
+        return unless @sitemap_index && ((!@sitemap_index.finalized? && !@protect_index) || force)
+
+        @sitemap_index.location[:create_index] =
+          value
       end
 
       # Set the namer to use to generate the sitemap (and index) file names.
@@ -629,7 +627,7 @@ module SitemapGenerator
       # the current sitemap and if there is no sitemap, creates a new one using
       # the current filename.
       def namer
-        @namer ||= @sitemap && @sitemap.location.namer || SitemapGenerator::SimpleNamer.new(@filename)
+        @namer ||= @sitemap&.location&.namer || SitemapGenerator::SimpleNamer.new(@filename)
       end
 
       # Set the value of the compress setting.
@@ -658,9 +656,12 @@ module SitemapGenerator
 
       # Update the given attribute on the current sitemap index and sitemap file location objects.
       # But don't create the index or sitemap files yet if they are not already created.
-      def update_location_info(attribute, value, opts={})
-        opts = SitemapGenerator::Utilities.reverse_merge(opts, :include_index => !@protect_index)
-        @sitemap_index.location[attribute] = value if opts[:include_index] && @sitemap_index && !@sitemap_index.finalized?
+      def update_location_info(attribute, value, opts = {})
+        opts = SitemapGenerator::Utilities.reverse_merge(opts, include_index: !@protect_index)
+        if opts[:include_index] && @sitemap_index && !@sitemap_index.finalized?
+          @sitemap_index.location[attribute] =
+            value
+        end
         @sitemap.location[attribute] = value if @sitemap && !@sitemap.finalized?
       end
     end

data/lib/sitemap_generator/railtie.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module SitemapGenerator
+  # Loads sitemap_generator rake tasks automatically when the gem is used in a Rails app.
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/sitemap_generator_tasks.rake"
+      load 'tasks/sitemap_generator_tasks.rake'
     end
   end
 end

data/lib/sitemap_generator/simple_namer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SitemapGenerator
   # A class for generating sitemap filenames.
   #
@@ -26,12 +28,11 @@ module SitemapGenerator
   #                is used, and subsequent names would be 'sitemap1.xml.gz', 'sitemap2.xml.gz', etc.
   #                In these examples the `base` string is assumed to be 'sitemap'.
   class SimpleNamer
-    def initialize(base, options={})
+    def initialize(base, options = {})
       @options = SitemapGenerator::Utilities.reverse_merge(options,
-        :zero => nil,  # identifies the marker for the start of the series
-        :extension => '.xml.gz',
-        :start => 1
-      )
+                                                           zero: nil, # marker for the start of the series
+                                                           extension: '.xml.gz',
+                                                           start: 1)
       @base = base
       reset
     end
@@ -63,7 +64,8 @@ module SitemapGenerator
 
     # Return this instance set to the previous name
     def previous
-      raise NameError, "Already at the start of the series" if start?
+      raise NameError, 'Already at the start of the series' if start?
+
       if @count <= @options[:start]
         @count = @options[:zero]
       else

data/lib/sitemap_generator/sitemap_location.rb

@@ -1,22 +1,25 @@
+# frozen_string_literal: true
+
 require 'sitemap_generator/helpers/number_helper'
 
 module SitemapGenerator
   # A class for determining the exact location at which to write sitemap data.
   # Handles reserving filenames from namers, constructing paths and sending
   # data to the adapter to be written out.
-  class SitemapLocation < Hash
+  class SitemapLocation < Hash # rubocop:disable Metrics/ClassLength
     include SitemapGenerator::Helpers::NumberHelper
 
     PATH_OUTPUT_WIDTH = 47 # Character width of the path in the summary lines
 
-    [:host, :adapter].each do |method|
+    %i[host adapter].each do |method|
       define_method(method) do
         raise SitemapGenerator::SitemapError, "No value set for #{method}" unless self[method]
+
         self[method]
       end
     end
 
-    [:public_path, :sitemaps_path].each do |method|
+    %i[public_path sitemaps_path].each do |method|
       define_method(method) do
         Pathname.new(SitemapGenerator::Utilities.append_slash(self[method]))
       end
@@ -45,36 +48,35 @@ module SitemapGenerator
     #   stripped from the filename.  If `:all_but_first`, only the `.gz` extension of the first
     #   filename is stripped off.  If `true` the extensions are left unchanged.
     # * <tt>max_sitemap_links</tt> - The maximum number of links to put in each sitemap.
-    def initialize(opts={})
-      SitemapGenerator::Utilities.assert_valid_keys(opts, [
-        :adapter,
-        :public_path,
-        :sitemaps_path,
-        :host,
-        :filename,
-        :namer,
-        :verbose,
-        :create_index,
-        :compress,
-        :max_sitemap_links
-      ])
+    def initialize(opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      super()
+      SitemapGenerator::Utilities.assert_valid_keys(opts, %i[
+                                                      adapter
+                                                      public_path
+                                                      sitemaps_path
+                                                      host
+                                                      filename
+                                                      namer
+                                                      verbose
+                                                      create_index
+                                                      compress
+                                                      max_sitemap_links
+                                                    ])
       opts[:adapter] ||= SitemapGenerator::FileAdapter.new
-      opts[:public_path] ||= SitemapGenerator.app.root + 'public/'
+      opts[:public_path] ||= SitemapGenerator.app.root + 'public/' # rubocop:disable Style/StringConcatenation
       # This is a bit of a hack to make the SimpleNamer act like the old SitemapNamer.
       # It doesn't really make sense to create a default namer like this because the
       # namer instance should be shared by the location objects of the sitemaps and
       # sitemap index files.  However, this greatly eases testing, so I'm leaving it in
       # for now.
-      if !opts[:filename] && !opts[:namer]
-        opts[:namer] = SitemapGenerator::SimpleNamer.new(:sitemap, :start => 2, :zero => 1)
-      end
-      opts[:verbose] = !!opts[:verbose]
-      self.merge!(opts)
+      opts[:namer] = SitemapGenerator::SimpleNamer.new(:sitemap, start: 2, zero: 1) if !opts[:filename] && !opts[:namer]
+      opts[:verbose] = !!opts[:verbose] # rubocop:disable Style/DoubleNegation
+      merge!(opts)
     end
 
     # Return a new Location instance with the given options merged in
-    def with(opts={})
-      self.merge(opts)
+    def with(opts = {})
+      merge(opts)
     end
 
     # Full path to the directory of the file.
@@ -98,17 +100,26 @@ module SitemapGenerator
     end
 
     # Return the size of the file at <tt>path</tt>
-    def filesize
+    def filesize # rubocop:disable Naming/PredicateMethod
       File.size?(path)
     end
 
+    def gzip?
+      /\.gz$/.match?(filename.to_s)
+    end
+
+    def content_type
+      gzip? ? 'application/x-gzip' : 'application/xml'
+    end
+
     # Return the filename.  Raises an exception if no filename or namer is set.
     # If using a namer once the filename has been retrieved from the namer its
     # value is locked so that it is unaffected by further changes to the namer.
-    def filename
-      raise SitemapGenerator::SitemapError, "No filename or namer set" unless self[:filename] || self[:namer]
+    def filename # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      raise SitemapGenerator::SitemapError, 'No filename or namer set' unless self[:filename] || self[:namer]
+
       unless self[:filename]
-        self.send(:[]=, :filename, self[:namer].to_s, :super => true)
+        send(:[]=, :filename, +self[:namer].to_s, super: true)
 
         # Post-process the filename for our compression settings.
         # Strip the `.gz` from the extension if we aren't compressing this file.
@@ -116,7 +127,7 @@ module SitemapGenerator
         # expected.  Ultimately I should force using a namer in all circumstances.
         # Changing the filename here will affect how the FileAdapter writes out the file.
         if self[:compress] == false ||
-           (self[:namer] && self[:namer].start? && self[:compress] == :all_but_first)
+           (self[:namer]&.start? && self[:compress] == :all_but_first)
           self[:filename].gsub!(/\.gz$/, '')
         end
       end
@@ -148,8 +159,8 @@ module SitemapGenerator
     end
 
     # If you set the filename, clear the namer and vice versa.
-    def []=(key, value, opts={})
-      if !opts[:super]
+    def []=(key, value, opts = {})
+      unless opts[:super]
         case key
         when :namer
           super(:filename, nil)
@@ -171,17 +182,18 @@ module SitemapGenerator
     def summary(link_count)
       filesize = number_to_human_size(self.filesize)
       width = self.class::PATH_OUTPUT_WIDTH
-      path = SitemapGenerator::Utilities.ellipsis(self.path_in_public, width)
-      "+ #{('%-'+width.to_s+'s') % path} #{'%10s' % link_count} links / #{'%10s' % filesize}"
+      path = SitemapGenerator::Utilities.ellipsis(path_in_public, width)
+      "+ #{format("%-#{width}s", path)} #{format('%10s', link_count)} links / #{format('%10s', filesize)}"
     end
   end
 
+  # SitemapLocation subclass for the sitemap index file.
+  # Defaults the namer to +:sitemap+ (no numeric suffix on the first name) and
+  # exposes the +create_index+ option.
   class SitemapIndexLocation < SitemapLocation
-    def initialize(opts={})
-      if !opts[:filename] && !opts[:namer]
-        opts[:namer] = SitemapGenerator::SimpleNamer.new(:sitemap)
-      end
-      super(opts)
+    def initialize(opts = {})
+      opts[:namer] = SitemapGenerator::SimpleNamer.new(:sitemap) if !opts[:filename] && !opts[:namer]
+      super
     end
 
     # Whether to create a sitemap index.  Default `:auto`.  See <tt>LinkSet::create_index=</tt>
@@ -197,8 +209,8 @@ module SitemapGenerator
     def summary(link_count)
       filesize = number_to_human_size(self.filesize)
       width = self.class::PATH_OUTPUT_WIDTH - 3
-      path = SitemapGenerator::Utilities.ellipsis(self.path_in_public, width)
-      "+ #{('%-'+width.to_s+'s') % path} #{'%10s' % link_count} sitemaps / #{'%10s' % filesize}"
+      path = SitemapGenerator::Utilities.ellipsis(path_in_public, width)
+      "+ #{format("%-#{width}s", path)} #{format('%10s', link_count)} sitemaps / #{format('%10s', filesize)}"
     end
   end
 end