sitemap_generator 6.3.0 → 7.1.1

data/lib/sitemap_generator/helpers/number_helper.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 # require "sitemap_generator/core_ext/big_decimal/conversions"
-require "sitemap_generator/utilities"
+require 'sitemap_generator/utilities'
 
 module SitemapGenerator
   # = SitemapGenerator Number Helpers
-  module Helpers #:nodoc:
-
+  module Helpers # :nodoc:
     # Provides methods for converting numbers into formatted strings.
     # Methods are provided for precision, positional notation and file size
     # and pretty printing.
     #
     # Most methods expect a +number+ argument, and will return it
     # unchanged if can't be converted into a valid number.
-    module NumberHelper
-
+    module NumberHelper # rubocop:disable Metrics/ModuleLength
       # Raised when argument +number+ param given to the helpers is invalid and
       # the option :raise is set to  +true+.
       class InvalidNumberError < StandardError
         attr_accessor :number
+
         def initialize(number)
+          super(number.to_s)
           @number = number
         end
       end
@@ -38,25 +40,23 @@ module SitemapGenerator
       #  number_with_delimiter(12345678.05, :locale => :fr)     # => 12 345 678,05
       #  number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
       #  # => 98 765 432,98
-      def number_with_delimiter(number, options = {})
+      def number_with_delimiter(number, options = {}) # rubocop:disable Metrics/MethodLength
         SitemapGenerator::Utilities.symbolize_keys!(options)
 
         begin
           Float(number)
         rescue ArgumentError, TypeError
-          if options[:raise]
-            raise InvalidNumberError, number
-          else
-            return number
-          end
+          raise InvalidNumberError, number if options[:raise]
+
+          return number
         end
 
         defaults = {
-          :separator => ".",
-          :delimiter => ",",
-          :precision => 3,
-          :significant => false,
-          :strip_insignificant_zeros => false
+          separator: '.',
+          delimiter: ',',
+          precision: 3,
+          significant: false,
+          strip_insignificant_zeros: false
         }
         options = SitemapGenerator::Utilities.reverse_merge(options, defaults)
 
@@ -72,10 +72,12 @@ module SitemapGenerator
       # ==== Options
       # * <tt>:locale</tt>     - Sets the locale to be used for formatting (defaults to current locale).
       # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
-      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +false+)
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits.
+      #                               If +false+, the # of fractional digits (defaults to +false+)
       # * <tt>:separator</tt>  - Sets the separator between the fractional and integer digits (defaults to ".").
       # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
-      # * <tt>:strip_insignificant_zeros</tt>  - If +true+ removes insignificant zeros after the decimal separator (defaults to +false+)
+      # * <tt>:strip_insignificant_zeros</tt>  - If +true+ removes insignificant zeros after the decimal separator
+      #                                             (defaults to +false+)
       #
       # ==== Examples
       #  number_with_precision(111.2345)                                            # => 111.235
@@ -91,62 +93,68 @@ module SitemapGenerator
       #  number_with_precision(389.32314, :precision => 4, :significant => true)    # => 389.3
       #  number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
       #  # => 1.111,23
-      def number_with_precision(number, options = {})
+      def number_with_precision(number, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         SitemapGenerator::Utilities.symbolize_keys!(options)
 
-        number = begin
-          Float(number)
+        begin
+          number = Float(number)
         rescue ArgumentError, TypeError
-          if options[:raise]
-            raise InvalidNumberError, number
-          else
-            return number
-          end
+          raise InvalidNumberError, number if options[:raise]
+
+          return number
         end
 
         defaults = {
-          :separator => ".",
-          :delimiter => ",",
-          :precision => 3,
-          :significant => false,
-          :strip_insignificant_zeros => false
+          separator: '.',
+          delimiter: ',',
+          precision: 3,
+          significant: false,
+          strip_insignificant_zeros: false
         }
         precision_defaults = {
-          :delimiter => ""
+          delimiter: ''
         }
         defaults = defaults.merge(precision_defaults)
 
-        options = SitemapGenerator::Utilities.reverse_merge(options, defaults)  # Allow the user to unset default values: Eg.: :significant => false
+        # Allow the user to unset default values: e.g. significant: false
+        options = SitemapGenerator::Utilities.reverse_merge(options, defaults)
         precision = options.delete :precision
         significant = options.delete :significant
         strip_insignificant_zeros = options.delete :strip_insignificant_zeros
 
-        if significant and precision > 0
-          if number == 0
-            digits, rounded_number = 1, 0
+        if significant && precision.positive?
+          if number.zero?
+            digits = 1
+            rounded_number = 0
           else
             digits = (Math.log10(number.abs) + 1).floor
-            rounded_number = (SitemapGenerator::BigDecimal.new(number.to_s) / SitemapGenerator::BigDecimal.new((10 ** (digits - precision)).to_f.to_s)).round.to_f * 10 ** (digits - precision)
+            step = SitemapGenerator::BigDecimal.new((10**(digits - precision)).to_f.to_s)
+            rounded_number = (SitemapGenerator::BigDecimal.new(number.to_s) / step)
+                             .round.to_f * (10**(digits - precision))
             digits = (Math.log10(rounded_number.abs) + 1).floor # After rounding, the number of digits may have changed
           end
-          precision = precision - digits
-          precision = precision > 0 ? precision : 0  #don't let it be negative
+          precision -= digits
+          precision = 0 unless precision.positive? # don't let it be negative
         else
-          rounded_number = SitemapGenerator::Utilities.round(SitemapGenerator::BigDecimal.new(number.to_s), precision).to_f
+          rounded_number = SitemapGenerator::Utilities.round(SitemapGenerator::BigDecimal.new(number.to_s),
+                                                             precision).to_f
         end
-        formatted_number = number_with_delimiter("%01.#{precision}f" % rounded_number, options)
+        formatted_number = number_with_delimiter(format("%01.#{precision}f", rounded_number), options)
         if strip_insignificant_zeros
           escaped_separator = Regexp.escape(options[:separator])
           formatted_number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
         else
           formatted_number
         end
-
       end
 
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
-      DECIMAL_UNITS = {0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand, 6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
-        -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro, -9 => :nano, -12 => :pico, -15 => :femto}.freeze
+      STORAGE_UNITS = %i[byte kb mb gb tb].freeze
+      DECIMAL_UNITS = {
+        0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand,
+        6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
+        -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro,
+        -9 => :nano, -12 => :pico, -15 => :femto
+      }.freeze
 
       # Formats the bytes in +number+ into a more understandable representation
       # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
@@ -158,10 +166,12 @@ module SitemapGenerator
       # ==== Options
       # * <tt>:locale</tt>     - Sets the locale to be used for formatting (defaults to current locale).
       # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
-      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +true+)
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits.
+      #                               If +false+, the # of fractional digits (defaults to +true+)
       # * <tt>:separator</tt>  - Sets the separator between the fractional and integer digits (defaults to ".").
       # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
-      # * <tt>:strip_insignificant_zeros</tt>  - If +true+ removes insignificant zeros after the decimal separator (defaults to +true+)
+      # * <tt>:strip_insignificant_zeros</tt>  - If +true+ removes insignificant zeros after the decimal separator
+      #                                             (defaults to +true+)
       # ==== Examples
       #  number_to_human_size(123)                                          # => 123 Bytes
       #  number_to_human_size(1234)                                         # => 1.21 KB
@@ -177,59 +187,57 @@ module SitemapGenerator
       # <tt>:strip_insignificant_zeros</tt> to +false+ to change that):
       #  number_to_human_size(1234567890123, :precision => 5)        # => "1.1229 TB"
       #  number_to_human_size(524288000, :precision=>5)              # => "500 MB"
-      def number_to_human_size(number, options = {})
+      def number_to_human_size(number, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         SitemapGenerator::Utilities.symbolize_keys!(options)
 
-        number = begin
-          Float(number)
+        begin
+          number = Float(number)
         rescue ArgumentError, TypeError
-          if options[:raise]
-            raise InvalidNumberError, number
-          else
-            return number
-          end
+          raise InvalidNumberError, number if options[:raise]
+
+          return number
         end
 
         defaults = {
-          :separator => ".",
-          :delimiter => ",",
-          :precision => 3,
-          :significant => false,
-          :strip_insignificant_zeros => false
+          separator: '.',
+          delimiter: ',',
+          precision: 3,
+          significant: false,
+          strip_insignificant_zeros: false
         }
         human = {
-          :delimiter => "",
-          :precision => 3,
-          :significant => true,
-          :strip_insignificant_zeros => true
+          delimiter: '',
+          precision: 3,
+          significant: true,
+          strip_insignificant_zeros: true
         }
         defaults = defaults.merge(human)
         options = SitemapGenerator::Utilities.reverse_merge(options, defaults)
-        #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
-        options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
+        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        options[:strip_insignificant_zeros] = true unless options.key?(:strip_insignificant_zeros)
 
-        storage_units_format = "%n %u"
+        storage_units_format = '%n %u'
 
         if number.to_i < 1024
-          unit = number.to_i > 1 || number.to_i == 0 ? 'Bytes' : 'Byte'
-          storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
+          unit = number.to_i > 1 || number.to_i.zero? ? 'Bytes' : 'Byte'
+          storage_units_format.gsub('%n', number.to_i.to_s).gsub('%u', unit)
         else
           max_exp  = STORAGE_UNITS.size - 1
           exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
           exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-          number  /= 1024 ** exponent
+          number  /= 1024**exponent
 
           unit_key = STORAGE_UNITS[exponent]
           units = {
-            :byte => "Bytes",
-            :kb => "KB",
-            :mb => "MB",
-            :gb => "GB",
-            :tb => "TB"
+            byte: 'Bytes',
+            kb: 'KB',
+            mb: 'MB',
+            gb: 'GB',
+            tb: 'TB'
           }
           unit = units[unit_key]
           formatted_number = number_with_precision(number, options)
-          storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
+          storage_units_format.gsub('%n', formatted_number).gsub('%u', unit)
         end
       end
     end

data/lib/sitemap_generator/interpreter.rb

@@ -1,15 +1,13 @@
+# frozen_string_literal: true
+
 require 'sitemap_generator'
 
 module SitemapGenerator
-
   # Provide a class for evaluating blocks, making the URL helpers from the framework
   # and API methods available to it.
   class Interpreter
-
     if SitemapGenerator.app.is_at_least_rails3?
-      if !::Rails.application.nil?
-        include ::Rails.application.routes.url_helpers
-      end
+      include ::Rails.application.routes.url_helpers unless ::Rails.application.nil?
     elsif SitemapGenerator.app.is_rails?
       require 'action_controller'
       include ActionController::UrlWriter
@@ -22,11 +20,17 @@ module SitemapGenerator
     # * <tt>link_set</tt> - a LinkSet instance to use.  Default is SitemapGenerator::Sitemap.
     #
     # All other options are passed to the LinkSet by setting them using accessor methods.
-    def initialize(opts={}, &block)
-      opts = SitemapGenerator::Utilities.reverse_merge(opts, :link_set => SitemapGenerator::Sitemap)
+    def initialize(opts = {}, &block)
+      opts = SitemapGenerator::Utilities.reverse_merge(opts, link_set: SitemapGenerator::Sitemap)
       @linkset = opts.delete :link_set
       @linkset.send(:set_options, opts)
-      eval(&block) if block_given?
+      eval(&block) if block_given? # rubocop:disable Security/Eval
+    end
+
+    def default_url_options
+      return {} unless defined?(ActionController::Base)
+
+      ActionController::Base.default_url_options || {}
     end
 
     def add(*args)
@@ -53,13 +57,13 @@ module SitemapGenerator
 
     # Evaluate the block in the interpreter.  Pass :yield_sitemap => true to
     # yield the Interpreter instance to the block...for old-style calling.
-    def eval(opts={}, &block)
-      if block_given?
-        if opts[:yield_sitemap]
-          yield @linkset
-        else
-          instance_eval(&block)
-        end
+    def eval(opts = {}, &block)
+      return unless block_given?
+
+      if opts[:yield_sitemap]
+        yield @linkset
+      else
+        instance_eval(&block)
       end
     end
 
@@ -70,11 +74,11 @@ module SitemapGenerator
     # * <tt>:config_file</tt> - full path to the config file to evaluate.
     #   Default is config/sitemap.rb in your application's root directory.
     # All other options are passed to +new+.
-    def self.run(opts={}, &block)
+    def self.run(opts = {})
       opts = opts.dup
       config_file = opts.delete(:config_file)
-      config_file ||= SitemapGenerator.app.root + 'config/sitemap.rb'
-      interpreter = self.new(opts)
+      config_file ||= SitemapGenerator.app.root + 'config/sitemap.rb' # rubocop:disable Style/StringConcatenation
+      interpreter = new(opts)
       interpreter.instance_eval(File.read(config_file), config_file.to_s)
       interpreter
     end