sitemap_generator 7.0.3 → 7.1.1

data/lib/sitemap_generator/adapters/file_adapter.rb

@@ -10,23 +10,26 @@ module SitemapGenerator
     #    compressed prior to being written out.  Otherwise the data will be written out
     #    unchanged.
     # @param raw_data - data to write to the file.
-    def write(location, raw_data)
+    def write(location, raw_data) # rubocop:disable Metrics/MethodLength
       # Ensure that the directory exists
       dir = location.directory
       if !File.exist?(dir)
         FileUtils.mkdir_p(dir)
       elsif !File.directory?(dir)
-        raise SitemapError.new("#{dir} should be a directory!")
+        raise SitemapError, "#{dir} should be a directory!"
       end
 
-      stream = open(location.path, 'wb')
-      if location.path.to_s =~ /.gz$/
-        gzip(stream, raw_data)
-      else
-        plain(stream, raw_data)
+      File.open(location.path, 'wb') do |stream|
+        if location.gzip?
+          gzip(stream, raw_data)
+        else
+          stream.write raw_data
+        end
       end
     end
 
+    private
+
     # Write `data` to a stream, passing the data through a GzipWriter
     # to compress it.
     def gzip(stream, data)
@@ -34,11 +37,5 @@ module SitemapGenerator
       gz.write data
       gz.close
     end
-
-    # Write `data` to a stream as is.
-    def plain(stream, data)
-      stream.write data
-      stream.close
-    end
   end
 end

data/lib/sitemap_generator/adapters/fog_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-if !defined?(Fog::Storage)
+unless defined?(Fog::Storage)
   raise LoadError, "Error: `Fog::Storage` is not defined.\n\n" \
-        "Please `require 'fog'` - or another library that defines this class."
+                   "Please `require 'fog'` - or another library that defines this class."
 end
 
 module SitemapGenerator

data/lib/sitemap_generator/adapters/google_storage_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-if !defined?(Google::Cloud::Storage)
+unless defined?(Google::Cloud::Storage)
   raise LoadError, "Error: `Google::Cloud::Storage` is not defined.\n\n" \
-        "Please `require 'google/cloud/storage'` - or another library that defines this class."
+                   "Please `require 'google/cloud/storage'` - or another library that defines this class."
 end
 
 module SitemapGenerator
@@ -12,7 +12,8 @@ module SitemapGenerator
     #
     # @param [Hash] opts Google::Cloud::Storage configuration options.
     # @option :bucket [String] Required. Name of Google Storage Bucket where the file is to be uploaded.
-    # @option :acl [String] Optional. Access control which is applied to the uploaded file(s).  Default value is 'public'.
+    # @option :acl [String] Optional. Access control which is applied to the uploaded file(s).
+    #                         Default value is 'public'.
     #
     # All options other than the `:bucket` and `:acl` options are passed to the `Google::Cloud::Storage.new`
     # initializer.  See https://googleapis.dev/ruby/google-cloud-storage/latest/file.AUTHENTICATION.html
@@ -25,7 +26,7 @@ module SitemapGenerator
     def initialize(opts = {})
       opts = opts.clone
       @bucket = opts.delete(:bucket)
-      @acl = opts.has_key?(:acl) ? opts.delete(:acl) : 'public'
+      @acl = opts.key?(:acl) ? opts.delete(:acl) : 'public'
       @storage_options = opts
     end
 

data/lib/sitemap_generator/adapters/s3_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-if !defined?(Fog::Storage)
+unless defined?(Fog::Storage)
   raise LoadError, "Error: `Fog::Storage` is not defined.\n\n" \
-        "Please `require 'fog-aws'` - or another library that defines this class."
+                   "Please `require 'fog-aws'` - or another library that defines this class."
 end
 
 module SitemapGenerator
@@ -22,21 +22,21 @@ module SitemapGenerator
     #
     # Alternatively you can use an environment variable to configure each option (except `fog_storage_options`).
     # The environment variables have the same name but capitalized, e.g. `FOG_PATH_STYLE`.
-    def initialize(opts = {})
-      @aws_access_key_id = opts[:aws_access_key_id] || ENV['AWS_ACCESS_KEY_ID']
-      @aws_secret_access_key = opts[:aws_secret_access_key] || ENV['AWS_SECRET_ACCESS_KEY']
-      @aws_session_token = opts[:aws_session_token] || ENV['AWS_SESSION_TOKEN']
-      @fog_provider = opts[:fog_provider] || ENV['FOG_PROVIDER']
-      @fog_directory = opts[:fog_directory] || ENV['FOG_DIRECTORY']
-      @fog_region = opts[:fog_region] || ENV['FOG_REGION']
-      @fog_path_style = opts[:fog_path_style] || ENV['FOG_PATH_STYLE']
+    def initialize(opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      @aws_access_key_id = opts[:aws_access_key_id] || ENV.fetch('AWS_ACCESS_KEY_ID', nil)
+      @aws_secret_access_key = opts[:aws_secret_access_key] || ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
+      @aws_session_token = opts[:aws_session_token] || ENV.fetch('AWS_SESSION_TOKEN', nil)
+      @fog_provider = opts[:fog_provider] || ENV.fetch('FOG_PROVIDER', nil)
+      @fog_directory = opts[:fog_directory] || ENV.fetch('FOG_DIRECTORY', nil)
+      @fog_region = opts[:fog_region] || ENV.fetch('FOG_REGION', nil)
+      @fog_path_style = opts[:fog_path_style] || ENV.fetch('FOG_PATH_STYLE', nil)
       @fog_storage_options = opts[:fog_storage_options] || {}
-      fog_public = opts[:fog_public].nil? ? ENV['FOG_PUBLIC'] : opts[:fog_public]
-      @fog_public = SitemapGenerator::Utilities.falsy?(fog_public) ? false : true
+      fog_public = opts[:fog_public].nil? ? ENV.fetch('FOG_PUBLIC', nil) : opts[:fog_public]
+      @fog_public = !SitemapGenerator::Utilities.falsy?(fog_public)
     end
 
     # Call with a SitemapLocation and string data
-    def write(location, raw_data)
+    def write(location, raw_data) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       SitemapGenerator::FileAdapter.new.write(location, raw_data)
 
       credentials = { provider: @fog_provider }
@@ -57,7 +57,8 @@ module SitemapGenerator
       directory.files.create(
         key: location.path_in_public,
         body: File.open(location.path),
-        public: @fog_public
+        public: @fog_public,
+        content_type: location.content_type
       )
     end
   end

data/lib/sitemap_generator/adapters/wave_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-if !defined?(::CarrierWave::Uploader::Base)
+unless defined?(CarrierWave::Uploader::Base)
   raise LoadError, "Error: `CarrierWave::Uploader::Base` is not defined.\n\n" \
-        "Please `require 'carrierwave'` - or another library that defines this class."
+                   "Please `require 'carrierwave'` - or another library that defines this class."
 end
 
 module SitemapGenerator
@@ -14,10 +14,10 @@ module SitemapGenerator
     def write(location, raw_data)
       SitemapGenerator::FileAdapter.new.write(location, raw_data)
       directory = File.dirname(location.path_in_public)
-      if directory != '.'
-        self.store_dir = directory
+      self.store_dir = directory if directory != '.'
+      File.open(location.path, 'rb') do |io|
+        store!(io)
       end
-      store!(open(location.path, 'rb'))
     end
   end
 end

data/lib/sitemap_generator/application.rb

@@ -3,17 +3,19 @@
 require 'pathname'
 
 module SitemapGenerator
+  # Thin abstraction over the host application environment.
+  # Provides the app +root+ path and Rails version detection.
   class Application
-    def is_rails?
+    def is_rails? # rubocop:disable Naming/PredicatePrefix
       !!defined?(Rails::VERSION)
     end
 
     # Returns a boolean indicating whether this environment is Rails 3
     #
     # @return [Boolean]
-    def is_at_least_rails3?
+    def is_at_least_rails3? # rubocop:disable Naming/PredicatePrefix
       is_rails? && Rails.version.to_f >= 3
-    rescue
+    rescue StandardError
       false # Rails.version defined in 2.1.0
     end
 

data/lib/sitemap_generator/builder/sitemap_file.rb

@@ -11,10 +11,12 @@ module SitemapGenerator
     #
     #   sitemap = SitemapFile.new(:location => SitemapLocation.new(...))
     #   sitemap.add('/', { ... })    <- add a link to the sitemap
-    #   sitemap.finalize!            <- write the sitemap file and freeze the object to protect it from further modification
+    #   sitemap.finalize!            <- write the sitemap file and freeze the object
+    #                                    to protect it from further modification
     #
     class SitemapFile
       include SitemapGenerator::Helpers::NumberHelper
+
       attr_reader :link_count, :filesize, :location, :news_count
 
       # === Options
@@ -22,7 +24,7 @@ module SitemapGenerator
       # * <tt>location</tt> - a SitemapGenerator::SitemapLocation instance or a Hash of options
       #   from which a SitemapLocation will be created for you.  See `SitemapGenerator::SitemapLocation` for
       #   the supported list of options.
-      def initialize(opts = {})
+      def initialize(opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         @location = opts.is_a?(Hash) ? SitemapGenerator::SitemapLocation.new(opts) : opts
         @link_count = 0
         @news_count = 0
@@ -46,33 +48,33 @@ module SitemapGenerator
         HTML
         @xml_wrapper_start.gsub!(/\s+/, ' ').gsub!(/ *> */, '>').strip!
         @xml_wrapper_end = '</urlset>'
-        @filesize = SitemapGenerator::Utilities.bytesize(@xml_wrapper_start) + SitemapGenerator::Utilities.bytesize(@xml_wrapper_end)
+        @filesize = SitemapGenerator::Utilities.bytesize(@xml_wrapper_start) +
+                    SitemapGenerator::Utilities.bytesize(@xml_wrapper_end)
         @xml_content = @xml_wrapper_start
         @written = false
         @reserved_name = nil # holds the name reserved from the namer
         @frozen = false      # rather than actually freeze, use this boolean
       end
 
-      # If a name has been reserved, use the last modified time from the file.
-      # Otherwise return nil.  We don't want to prematurely assign a name
-      # for this sitemap if one has not yet been reserved, because we may
-      # mess up the name-assignment sequence.
+      # Return the time the sitemap was written, or nil if it has not been written yet.
+      # Returning nil before write prevents prematurely reserving a name in the
+      # namer sequence.
       def lastmod
-        File.mtime(location.path) if location.reserved_name?
-      rescue
-        nil
+        @lastmod if location.reserved_name?
       end
 
       def empty?
-        @link_count == 0
+        @link_count.zero?
       end
 
       # Return a boolean indicating whether the sitemap file can fit another link
       # of <tt>bytes</tt> bytes in size.  You can also pass a string and the
       # bytesize will be calculated for you.
       def file_can_fit?(bytes)
-        bytes = bytes.is_a?(String) ? SitemapGenerator::Utilities.bytesize(bytes) : bytes
-        (@filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE && @link_count < max_sitemap_links && @news_count < SitemapGenerator::MAX_SITEMAP_NEWS
+        bytes = SitemapGenerator::Utilities.bytesize(bytes) if bytes.is_a?(String)
+        (@filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE &&
+          @link_count < max_sitemap_links &&
+          @news_count < SitemapGenerator::MAX_SITEMAP_NEWS
       end
 
       # Add a link to the sitemap file.
@@ -94,7 +96,7 @@ module SitemapGenerator
       #
       # The link added to the sitemap will use the host from its location object
       # if no host has been specified.
-      def add(link, options = {})
+      def add(link, options = {}) # rubocop:disable Metrics/MethodLength
         raise SitemapGenerator::SitemapFinalizedError if finalized?
 
         sitemap_url =
@@ -106,11 +108,9 @@ module SitemapGenerator
           end
 
         xml = sitemap_url.to_xml
-        raise SitemapGenerator::SitemapFullError if !file_can_fit?(xml)
+        raise SitemapGenerator::SitemapFullError unless file_can_fit?(xml)
 
-        if sitemap_url.news?
-          @news_count += 1
-        end
+        @news_count += 1 if sitemap_url.news?
 
         # Add the XML to the sitemap
         @xml_content << xml
@@ -140,12 +140,13 @@ module SitemapGenerator
       # A SitemapGenerator::SitemapError exception is raised if the file has
       # already been written.
       def write
-        raise SitemapGenerator::SitemapError.new('Sitemap already written!') if written?
+        raise SitemapGenerator::SitemapError, 'Sitemap already written!' if written?
 
         finalize! unless finalized?
         reserve_name
         @xml_content << @xml_wrapper_end
         @location.write(@xml_content, link_count)
+        @lastmod = SitemapGenerator::Utilities.current_time
         @xml_content = @xml_wrapper_end = ''
         @written = true
       end
@@ -158,7 +159,7 @@ module SitemapGenerator
       # Reserve a name from the namer unless one has already been reserved.
       # Safe to call more than once.
       def reserve_name
-        @reserved_name ||= @location.reserve_name
+        @reserved_name ||= @location.reserve_name # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       # Return a boolean indicating whether a name has been reserved

data/lib/sitemap_generator/builder/sitemap_index_file.rb

@@ -2,13 +2,15 @@
 
 module SitemapGenerator
   module Builder
+    # Builds the sitemap index XML file, listing all sitemap files.
+    # Manages deferred naming (waits for a second sitemap before reserving the index name)
+    # and controls whether an index is written at all via +create_index+.
     class SitemapIndexFile < SitemapFile
-
       # === Options
       #
       # * <tt>location</tt> - a SitemapGenerator::SitemapIndexLocation instance or a Hash of options
       #   from which a SitemapLocation will be created for you.
-      def initialize(opts = {})
+      def initialize(opts = {}) # rubocop:disable Lint/MissingSuper, Metrics/MethodLength
         @location = opts.is_a?(Hash) ? SitemapGenerator::SitemapIndexLocation.new(opts) : opts
         @link_count = 0
         @sitemaps_link_count = 0
@@ -49,9 +51,9 @@ module SitemapGenerator
       # If a link is being added to the index manually as a string, then we
       # can assume that the index is required (unless create_index is false of course).
       # This seems like the logical thing to do.
-      alias_method :super_add, :add
-      def add(link, options = {})
-        if file = link.is_a?(SitemapFile) && link
+      alias super_add add
+      def add(link, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        if (file = link.is_a?(SitemapFile) && link)
           @sitemaps_link_count += file.link_count
           file.finalize! unless file.finalized?
 
@@ -62,7 +64,7 @@ module SitemapGenerator
           # first name (the index, or the sitemap).  If the item is not a SitemapFile,
           # then it has been manually added and we can be sure that the user intends
           # for there to be an index.
-          if @link_count == 0
+          if @link_count.zero?
             @first_sitemap = SitemapGenerator::Builder::LinkHolder.new(file, options)
             @link_count += 1 # pretend it's added, but don't add it yet
           else
@@ -90,7 +92,7 @@ module SitemapGenerator
       # of <tt>bytes</tt> bytes in size.  You can also pass a string and the
       # bytesize will be calculated for you.
       def file_can_fit?(bytes)
-        bytes = bytes.is_a?(String) ? SitemapGenerator::Utilities.bytesize(bytes) : bytes
+        bytes = SitemapGenerator::Utilities.bytesize(bytes) if bytes.is_a?(String)
         (@filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE && @link_count < SitemapGenerator::MAX_SITEMAP_FILES
       end
 
@@ -101,7 +103,7 @@ module SitemapGenerator
 
       def stats_summary(opts = {})
         str = "Sitemap stats: #{number_with_delimiter(@sitemaps_link_count)} links / #{@link_count} sitemaps"
-        str += ' / %dm%02ds' % opts[:time_taken].divmod(60) if opts[:time_taken]
+        str + format(' / %dm%02ds', *opts[:time_taken].divmod(60)) if opts[:time_taken] # rubocop:disable Style/FormatStringToken
       end
 
       def finalize!
@@ -122,7 +124,7 @@ module SitemapGenerator
       # If a link is added manually and create_index is not false, we force index
       # creation because they obviously intend for there to be an index.  False otherwise.
       def create_index?
-        @create_index || @location.create_index == true || @location.create_index == :auto && @link_count > 1
+        @create_index || @location.create_index == true || (@location.create_index == :auto && @link_count > 1)
       end
 
       # Return the index file URL.  If create_index is true, this is the URL
@@ -141,15 +143,15 @@ module SitemapGenerator
 
       # Make sure the first sitemap has been written out and added to the index
       def write_first_sitemap
-        if @first_sitemap
-          @first_sitemap.link.write unless @first_sitemap.link.written?
-          super_add(SitemapGenerator::Builder::SitemapIndexUrl.new(@first_sitemap.link, @first_sitemap.options))
-          @link_count -= 1 # we already counted it, don't count it twice
-          # Store the URL because if create_index is false, this is the
-          # "index" URL
-          @first_sitemap_url = @first_sitemap.link.location.url
-          @first_sitemap = nil
-        end
+        return unless @first_sitemap
+
+        @first_sitemap.link.write unless @first_sitemap.link.written?
+        super_add(SitemapGenerator::Builder::SitemapIndexUrl.new(@first_sitemap.link, @first_sitemap.options))
+        @link_count -= 1 # we already counted it, don't count it twice
+        # Store the URL because if create_index is false, this is the
+        # "index" URL
+        @first_sitemap_url = @first_sitemap.link.location.url
+        @first_sitemap = nil
       end
     end
   end

data/lib/sitemap_generator/builder/sitemap_index_url.rb

@@ -4,16 +4,15 @@ require 'builder'
 
 module SitemapGenerator
   module Builder
+    # Wraps a sitemap file reference as a +<sitemap>+ XML entry for use in a sitemap index.
     class SitemapIndexUrl < SitemapUrl
-
       def initialize(path, options = {})
-        if index = path.is_a?(SitemapGenerator::Builder::SitemapIndexFile) && path
-          options = SitemapGenerator::Utilities.reverse_merge(options, host: index.location.host, lastmod: Time.now, priority: 1.0)
+        if (index = path.is_a?(SitemapGenerator::Builder::SitemapIndexFile) && path)
+          options = SitemapGenerator::Utilities.reverse_merge(options, host: index.location.host, lastmod: SitemapGenerator::Utilities.current_time,
+                                                                       priority: 1.0)
           path = index.location.path_in_public
-          super(path, options)
-        else
-          super
         end
+        super
       end
 
       # Return the URL as XML

data/lib/sitemap_generator/builder/sitemap_url.rb

@@ -9,8 +9,7 @@ module SitemapGenerator
   module Builder
     # A Hash-like class for holding information about a sitemap URL and
     # generating an XML <url> element suitable for sitemaps.
-    class SitemapUrl < Hash
-
+    class SitemapUrl < Hash # rubocop:disable Metrics/ClassLength
       # Return a new instance with options configured on it.
       #
       # == Arguments
@@ -31,9 +30,10 @@ module SitemapGenerator
       # * +mobile+
       # * +alternate+/+alternates+
       # * +pagemap+
-      def initialize(path, options = {})
+      def initialize(path, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        super()
         options = SitemapGenerator::Utilities.symbolize_keys(options)
-        if sitemap = path.is_a?(SitemapGenerator::Builder::SitemapFile) && path
+        if (sitemap = path.is_a?(SitemapGenerator::Builder::SitemapFile) && path)
           SitemapGenerator::Utilities.reverse_merge!(
             options,
             host: sitemap.location.host,
@@ -44,13 +44,15 @@ module SitemapGenerator
 
         SitemapGenerator::Utilities.assert_valid_keys(
           options,
-          :priority, :changefreq, :lastmod, :expires, :host, :images, :video, :news, :videos, :mobile, :alternate, :alternates, :pagemap
+          :priority, :changefreq, :lastmod, :expires, :host,
+          :images, :video, :news, :videos, :mobile,
+          :alternate, :alternates, :pagemap
         )
         SitemapGenerator::Utilities.reverse_merge!(
           options,
           priority: 0.5,
           changefreq: 'weekly',
-          lastmod: Time.now,
+          lastmod: SitemapGenerator::Utilities.current_time,
           images: [],
           news: {},
           videos: [],
@@ -59,16 +61,17 @@ module SitemapGenerator
         )
         raise 'Cannot generate a url without a host' unless SitemapGenerator::Utilities.present?(options[:host])
 
-        if video = options.delete(:video)
+        if (video = options.delete(:video))
           options[:videos] = video.is_a?(Array) ? options[:videos].concat(video) : options[:videos] << video
         end
-        if alternate = options.delete(:alternate)
-          options[:alternates] = alternate.is_a?(Array) ? options[:alternates].concat(alternate) : options[:alternates] << alternate
+        if (alternate = options.delete(:alternate))
+          options[:alternates] =
+            alternate.is_a?(Array) ? options[:alternates].concat(alternate) : options[:alternates] << alternate
         end
 
-        path = path.to_s.sub(/^\//, '')
-        loc  = path.empty? ? options[:host] : (options[:host].to_s.sub(/\/$/, '') + '/' + path)
-        self.merge!(
+        path = encode_non_ascii(path.to_s.sub(%r{^/}, ''))
+        loc  = path.empty? ? options[:host] : "#{options[:host].to_s.sub(%r{/$}, '')}/#{path}"
+        merge!(
           priority: options[:priority],
           changefreq: options[:changefreq],
           lastmod: options[:lastmod],
@@ -79,15 +82,15 @@ module SitemapGenerator
           news: prepare_news(options[:news]),
           videos: options[:videos],
           mobile: options[:mobile],
-          alternates: options[:alternates],
+          alternates: prepare_alternates(options[:alternates], options[:host]),
           pagemap: options[:pagemap]
         )
       end
 
       # Return the URL as XML
-      def to_xml(builder = nil)
+      def to_xml(builder = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         builder = ::Builder::XmlMarkup.new if builder.nil?
-        builder.url do
+        builder.url do # rubocop:disable Metrics/BlockLength
           builder.loc        self[:loc]
           builder.lastmod    w3c_date(self[:lastmod])      if self[:lastmod]
           builder.expires    w3c_date(self[:expires])      if self[:expires]
@@ -121,15 +124,17 @@ module SitemapGenerator
             end
           end
 
-          self[:videos].each do |video|
-            builder.video :video do
+          self[:videos].each do |video| # rubocop:disable Metrics/BlockLength
+            builder.video :video do # rubocop:disable Metrics/BlockLength
               builder.video :thumbnail_loc, video[:thumbnail_loc].to_s
               builder.video :title, video[:title].to_s
               builder.video :description, video[:description].to_s
               builder.video :content_loc, video[:content_loc].to_s if video[:content_loc]
               if video[:player_loc]
                 loc_attributes = { allow_embed: yes_or_no_with_default(video[:allow_embed], true) }
-                loc_attributes[:autoplay] = video[:autoplay].to_s if SitemapGenerator::Utilities.present?(video[:autoplay])
+                if SitemapGenerator::Utilities.present?(video[:autoplay])
+                  loc_attributes[:autoplay] = video[:autoplay].to_s
+                end
                 builder.video :player_loc, video[:player_loc].to_s, loc_attributes
               end
               builder.video :duration, video[:duration].to_s if video[:duration]
@@ -137,17 +142,30 @@ module SitemapGenerator
               builder.video :rating, format_float(video[:rating]) if video[:rating]
               builder.video :view_count, video[:view_count].to_s if video[:view_count]
               builder.video :publication_date, w3c_date(video[:publication_date]) if video[:publication_date]
-              video[:tags].each { |tag| builder.video :tag, tag.to_s }       if video[:tags]
+              video[:tags]&.each { |tag| builder.video :tag, tag.to_s }
               builder.video :tag, video[:tag].to_s                           if video[:tag]
               builder.video :category, video[:category].to_s                 if video[:category]
-              builder.video :family_friendly, yes_or_no_with_default(video[:family_friendly], true) if video.has_key?(:family_friendly)
-              builder.video :gallery_loc, video[:gallery_loc].to_s, title: video[:gallery_title].to_s if video[:gallery_loc]
-              builder.video :price, video[:price].to_s, prepare_video_price_attribs(video) if SitemapGenerator::Utilities.present?(video[:price])
+              if video.key?(:family_friendly)
+                builder.video :family_friendly,
+                              yes_or_no_with_default(video[:family_friendly], true)
+              end
+              if video[:gallery_loc]
+                builder.video :gallery_loc, video[:gallery_loc].to_s,
+                              title: video[:gallery_title].to_s
+              end
+              if SitemapGenerator::Utilities.present?(video[:price])
+                builder.video :price, video[:price].to_s, prepare_video_price_attribs(video)
+              end
               if video[:uploader]
-                builder.video :uploader, video[:uploader].to_s, video[:uploader_info] ? { info: video[:uploader_info].to_s } : {}
+                builder.video :uploader, video[:uploader].to_s,
+                              video[:uploader_info] ? { info: video[:uploader_info].to_s } : {}
+              end
+              builder.video :live, yes_or_no_with_default(video[:live], true) if video.key?(:live)
+              if video.key?(:requires_subscription)
+                builder.video :requires_subscription,
+                              yes_or_no_with_default(video[:requires_subscription],
+                                                     true)
               end
-              builder.video :live, yes_or_no_with_default(video[:live], true) if video.has_key?(:live)
-              builder.video :requires_subscription, yes_or_no_with_default(video[:requires_subscription], true) if video.has_key?(:requires_subscription)
             end
           end
 
@@ -159,9 +177,7 @@ module SitemapGenerator
             builder.xhtml :link, attributes
           end
 
-          unless SitemapGenerator::Utilities.blank?(self[:mobile])
-            builder.mobile :mobile
-          end
+          builder.mobile :mobile unless SitemapGenerator::Utilities.blank?(self[:mobile])
 
           unless SitemapGenerator::Utilities.blank?(self[:pagemap])
             builder.pagemap :PageMap do
@@ -188,18 +204,40 @@ module SitemapGenerator
         attribs = {}
         attribs[:currency] = video[:price_currency].to_s # required
         attribs[:type] = video[:price_type] if SitemapGenerator::Utilities.present?(video[:price_type])
-        attribs[:resolution] = video[:price_resolution] if SitemapGenerator::Utilities.present?(video[:price_resolution])
+        if SitemapGenerator::Utilities.present?(video[:price_resolution])
+          attribs[:resolution] = video[:price_resolution]
+        end
         attribs
       end
 
       def prepare_news(news)
-        SitemapGenerator::Utilities.assert_valid_keys(news, :publication_name, :publication_language, :publication_date, :genres, :access, :title, :keywords, :stock_tickers) unless news.empty?
+        unless news.empty?
+          SitemapGenerator::Utilities.assert_valid_keys(
+            news,
+            :publication_name, :publication_language, :publication_date,
+            :genres, :access, :title, :keywords, :stock_tickers
+          )
+        end
         news
       end
 
+      # Return an Array of alternate option Hashes with relative hrefs expanded to absolute URLs.
+      def prepare_alternates(alternates, host)
+        alternates.map do |alt|
+          next alt unless alt.is_a?(Hash)
+
+          href = alt[:href].to_s
+          if href.start_with?('/')
+            alt.merge(href: URI.join(host, href).to_s)
+          else
+            alt
+          end
+        end
+      end
+
       # Return an Array of image option Hashes suitable to be parsed by SitemapGenerator::Builder::SitemapFile
       def prepare_images(images, host)
-        images.delete_if { |key, value| key[:loc] == nil }
+        images.delete_if { |key, _value| key[:loc].nil? }
         images.each do |r|
           SitemapGenerator::Utilities.assert_valid_keys(r, :loc, :caption, :geo_location, :title, :license)
           r[:loc] = URI.join(host, r[:loc]).to_s
@@ -207,7 +245,7 @@ module SitemapGenerator
         images[0..(SitemapGenerator::MAX_SITEMAP_IMAGES - 1)]
       end
 
-      def w3c_date(date)
+      def w3c_date(date) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         if date.is_a?(String)
           date
         elsif date.respond_to?(:iso8601)
@@ -222,8 +260,6 @@ module SitemapGenerator
               date.utc
             elsif date.is_a?(Integer)
               Time.at(date).utc
-            else
-              nil
             end
 
           if zulutime
@@ -239,7 +275,9 @@ module SitemapGenerator
       # value must be 'yes' or 'no'.  Pass the default value as a boolean using `default`.
       def yes_or_no(value)
         if value.is_a?(String)
-          raise ArgumentError.new("Unrecognized value for yes/no field: #{value.inspect}") unless value =~ /^(yes|no)$/i
+          unless /^(yes|no)$/i.match?(value)
+            raise ArgumentError, "Unrecognized value for yes/no field: #{value.inspect}"
+          end
 
           value.downcase
         else
@@ -256,7 +294,15 @@ module SitemapGenerator
       # Format a float to to one decimal precision.
       # TODO: Use rounding with precision once merged with framework_agnostic.
       def format_float(value)
-        value.is_a?(String) ? value : ('%0.1f' % value)
+        value.is_a?(String) ? value : format('%0.1f', value)
+      end
+
+      private
+
+      # Percent-encode non-ASCII bytes in a path segment, leaving already-encoded %XX sequences untouched.
+      # Applied to paths only — not the host — IDN hostnames require punycode, not percent-encoding.
+      def encode_non_ascii(str)
+        str.gsub(/[^\x00-\x7F]/) { |c| c.bytes.map { |b| format('%%%02X', b) }.join }
       end
     end
   end