sitemap_generator 6.3.0 → 7.1.1

data/lib/sitemap_generator/builder/sitemap_index_url.rb

@@ -1,25 +1,26 @@
+# frozen_string_literal: true
+
 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)
+      def initialize(path, options = {})
+        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
-      def to_xml(builder=nil)
+      def to_xml(builder = nil)
         builder = ::Builder::XmlMarkup.new if builder.nil?
         builder.sitemap do
           builder.loc        self[:loc]
-          builder.lastmod    w3c_date(self[:lastmod])   if self[:lastmod]
+          builder.lastmod    w3c_date(self[:lastmod]) if self[:lastmod]
         end
         builder << '' # force to string
       end

data/lib/sitemap_generator/builder/sitemap_url.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'builder'
 require 'uri'
 require 'time'
@@ -7,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
@@ -29,63 +30,67 @@ 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,
-            :lastmod => sitemap.lastmod
+            host: sitemap.location.host,
+            lastmod: sitemap.lastmod
           )
           path = sitemap.location.path_in_public
         end
 
         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,
-          :images => [],
-          :news => {},
-          :videos => [],
-          :mobile => false,
-          :alternates => []
+          priority: 0.5,
+          changefreq: 'weekly',
+          lastmod: SitemapGenerator::Utilities.current_time,
+          images: [],
+          news: {},
+          videos: [],
+          mobile: false,
+          alternates: []
         )
-        raise "Cannot generate a url without a host" unless SitemapGenerator::Utilities.present?(options[:host])
+        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!(
-          :priority   => options[:priority],
-          :changefreq => options[:changefreq],
-          :lastmod    => options[:lastmod],
-          :expires    => options[:expires],
-          :host       => options[:host],
-          :loc        => loc,
-          :images     => prepare_images(options[:images], options[:host]),
-          :news       => prepare_news(options[:news]),
-          :videos     => options[:videos],
-          :mobile     => options[:mobile],
-          :alternates => options[:alternates],
-          :pagemap    => options[:pagemap]
+        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],
+          expires: options[:expires],
+          host: options[:host],
+          loc: loc,
+          images: prepare_images(options[:images], options[:host]),
+          news: prepare_news(options[:news]),
+          videos: options[:videos],
+          mobile: options[:mobile],
+          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]
@@ -94,8 +99,8 @@ module SitemapGenerator
 
           unless SitemapGenerator::Utilities.blank?(self[:news])
             news_data = self[:news]
-            builder.news:news do
-              builder.news:publication do
+            builder.news :news do
+              builder.news :publication do
                 builder.news :name, news_data[:publication_name].to_s if news_data[:publication_name]
                 builder.news :language, news_data[:publication_language].to_s if news_data[:publication_language]
               end
@@ -110,7 +115,7 @@ module SitemapGenerator
           end
 
           self[:images].each do |image|
-            builder.image:image do
+            builder.image :image do
               builder.image :loc, image[:loc]
               builder.image :caption, image[:caption].to_s             if image[:caption]
               builder.image :geo_location, image[:geo_location].to_s   if image[:geo_location]
@@ -119,54 +124,67 @@ 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]
+              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])
+                loc_attributes = { allow_embed: yes_or_no_with_default(video[:allow_embed], true) }
+                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]
-              builder.video :expiration_date,  w3c_date(video[:expiration_date])  if video[:expiration_date]
-              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 :duration, video[:duration].to_s if video[:duration]
+              builder.video :expiration_date, w3c_date(video[:expiration_date]) if video[:expiration_date]
+              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
 
           self[:alternates].each do |alternate|
             rel = alternate[:nofollow] ? 'alternate nofollow' : 'alternate'
-            attributes = { :rel => rel, :href => alternate[:href].to_s }
+            attributes = { rel: rel, href: alternate[:href].to_s }
             attributes[:hreflang] = alternate[:lang].to_s if SitemapGenerator::Utilities.present?(alternate[:lang])
             attributes[:media] = alternate[:media].to_s if SitemapGenerator::Utilities.present?(alternate[:media])
             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
               SitemapGenerator::Utilities.as_array(self[:pagemap][:dataobjects]).each do |dataobject|
-                builder.pagemap :DataObject, :type => dataobject[:type].to_s, :id => dataobject[:id].to_s do
+                builder.pagemap :DataObject, type: dataobject[:type].to_s, id: dataobject[:id].to_s do
                   SitemapGenerator::Utilities.as_array(dataobject[:attributes]).each do |attribute|
-                    builder.pagemap :Attribute, attribute[:value].to_s, :name => attribute[:name].to_s
+                    builder.pagemap :Attribute, attribute[:value].to_s, name: attribute[:name].to_s
                   end
                 end
               end
@@ -186,48 +204,69 @@ 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
         end
-        images[0..(SitemapGenerator::MAX_SITEMAP_IMAGES-1)]
+        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)
           date.iso8601.sub(/Z$/i, '+00:00')
         elsif date.is_a?(Date) && !date.is_a?(DateTime)
-          date.strftime("%Y-%m-%d")
+          date.strftime('%Y-%m-%d')
         else
-          zulutime = if date.is_a?(DateTime)
-            date.new_offset(0)
-          elsif date.respond_to?(:utc)
-            date.utc
-          elsif date.is_a?(Integer)
-            Time.at(date).utc
-          else
-            nil
-          end
+          zulutime =
+            if date.is_a?(DateTime)
+              date.new_offset(0)
+            elsif date.respond_to?(:utc)
+              date.utc
+            elsif date.is_a?(Integer)
+              Time.at(date).utc
+            end
 
           if zulutime
-            zulutime.strftime("%Y-%m-%dT%H:%M:%S+00:00")
+            zulutime.strftime('%Y-%m-%dT%H:%M:%S+00:00')
           else
             zone = date.strftime('%z').insert(-3, ':')
-            date.strftime("%Y-%m-%dT%H:%M:%S") + zone
+            date.strftime('%Y-%m-%dT%H:%M:%S') + zone
           end
         end
       end
@@ -236,7 +275,10 @@ 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
           value ? 'yes' : 'no'
@@ -252,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

data/lib/sitemap_generator/builder.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require 'sitemap_generator/builder/sitemap_file'
 require 'sitemap_generator/builder/sitemap_index_file'
 require 'sitemap_generator/builder/sitemap_url'
 require 'sitemap_generator/builder/sitemap_index_url'
 
-module SitemapGenerator::Builder
-  LinkHolder = Struct.new(:link, :options)
-end
+module SitemapGenerator
+  module Builder
+    LinkHolder = Struct.new(:link, :options)
+  end
+end

data/lib/sitemap_generator/core_ext/big_decimal.rb

@@ -1,55 +1,62 @@
+# frozen_string_literal: true
+
 require 'bigdecimal'
 
 begin
   require 'psych'
 rescue LoadError
+  # psych is optional; fall back gracefully if unavailable
 end
 
 require 'yaml'
 
 # Define our own class rather than modify the global class
-class SitemapGenerator::BigDecimal
-  YAML_TAG = 'tag:yaml.org,2002:float'
-  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
+module SitemapGenerator
+  # Scoped BigDecimal wrapper that serializes to YAML without scientific notation.
+  # Defined here rather than reopening the global BigDecimal class.
+  class BigDecimal
+    YAML_TAG = 'tag:yaml.org,2002:float'
+    YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }.freeze
 
-  yaml_tag YAML_TAG
+    yaml_tag YAML_TAG
 
-  def initialize(num)
-    @value = BigDecimal(num)
-  end
+    def initialize(num)
+      @value = BigDecimal(num)
+    end
 
-  def *(other)
-    other * @value
-  end
+    def *(other)
+      other * @value
+    end
 
-  def /(other)
-    SitemapGenerator::BigDecimal === other ? @value / other.instance_variable_get(:@value) : @value / other
-  end
+    def /(other)
+      other.is_a?(SitemapGenerator::BigDecimal) ? @value / other.instance_variable_get(:@value) : @value / other
+    end
 
-  # This emits the number without any scientific notation.
-  # This is better than self.to_f.to_s since it doesn't lose precision.
-  #
-  # Note that reconstituting YAML floats to native floats may lose precision.
-  def to_yaml(opts = {})
-    return super unless defined?(YAML::ENGINE) && YAML::ENGINE.syck?
+    # This emits the number without any scientific notation.
+    # This is better than self.to_f.to_s since it doesn't lose precision.
+    #
+    # Note that reconstituting YAML floats to native floats may lose precision.
+    def to_yaml(opts = {})
+      return super unless defined?(YAML::ENGINE) && YAML::ENGINE.syck?
+
+      YAML.quick_emit(nil, opts) do |out|
+        string = to_s
+        out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
+      end
+    end
 
-    YAML.quick_emit(nil, opts) do |out|
+    def encode_with(coder)
       string = to_s
-      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
+      coder.represent_scalar(nil, YAML_MAPPING[string] || string)
     end
-  end
-
-  def encode_with(coder)
-    string = to_s
-    coder.represent_scalar(nil, YAML_MAPPING[string] || string)
-  end
 
-  def to_d
-    self
-  end
+    def to_d
+      self
+    end
 
-  DEFAULT_STRING_FORMAT = 'F'
-  def to_s(format = DEFAULT_STRING_FORMAT)
-    @value.to_s(format)
+    DEFAULT_STRING_FORMAT = 'F'
+    def to_s(format = DEFAULT_STRING_FORMAT)
+      @value.to_s(format)
+    end
   end
 end

data/lib/sitemap_generator/core_ext/numeric.rb

@@ -1,48 +1,54 @@
-class SitemapGenerator::Numeric
-  KILOBYTE = 1024
-  MEGABYTE = KILOBYTE * 1024
-  GIGABYTE = MEGABYTE * 1024
-  TERABYTE = GIGABYTE * 1024
-  PETABYTE = TERABYTE * 1024
-  EXABYTE  = PETABYTE * 1024
-
-  def initialize(number)
-    @number = number
+# frozen_string_literal: true
+
+module SitemapGenerator
+  # Scoped Numeric wrapper providing byte-unit helpers (+kilobytes+, +megabytes+, etc.).
+  # Defined here rather than reopening the global Numeric class.
+  class Numeric
+    KILOBYTE = 1024
+    MEGABYTE = KILOBYTE * 1024
+    GIGABYTE = MEGABYTE * 1024
+    TERABYTE = GIGABYTE * 1024
+    PETABYTE = TERABYTE * 1024
+    EXABYTE  = PETABYTE * 1024
+
+    def initialize(number)
+      @number = number
+    end
+
+    # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+    def bytes
+      @number
+    end
+    alias byte bytes
+
+    def kilobytes
+      @number * KILOBYTE
+    end
+    alias kilobyte kilobytes
+
+    def megabytes
+      @number * MEGABYTE
+    end
+    alias megabyte megabytes
+
+    def gigabytes
+      @number * GIGABYTE
+    end
+    alias gigabyte gigabytes
+
+    def terabytes
+      @number * TERABYTE
+    end
+    alias terabyte terabytes
+
+    def petabytes
+      @number * PETABYTE
+    end
+    alias petabyte petabytes
+
+    def exabytes
+      @number * EXABYTE
+    end
+    alias exabyte exabytes
   end
-
-  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-  def bytes
-    @number
-  end
-  alias :byte :bytes
-
-  def kilobytes
-    @number * KILOBYTE
-  end
-  alias :kilobyte :kilobytes
-
-  def megabytes
-    @number * MEGABYTE
-  end
-  alias :megabyte :megabytes
-
-  def gigabytes
-    @number * GIGABYTE
-  end
-  alias :gigabyte :gigabytes
-
-  def terabytes
-    @number * TERABYTE
-  end
-  alias :terabyte :terabytes
-
-  def petabytes
-    @number * PETABYTE
-  end
-  alias :petabyte :petabytes
-
-  def exabytes
-    @number * EXABYTE
-  end
-  alias :exabyte :exabytes
 end

data/lib/sitemap_generator/core_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Dir["#{File.dirname(__FILE__)}/core_ext/**/*.rb"].sort.each do |path|
   require path
 end