sitemap_generator 7.0.3 → 7.1.0

data/lib/sitemap_generator/core_ext/big_decimal.rb

@@ -5,53 +5,58 @@ 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,50 +1,54 @@
 # frozen_string_literal: true
 
-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
+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/helpers/number_helper.rb

@@ -6,20 +6,20 @@ require 'sitemap_generator/utilities'
 module SitemapGenerator
   # = SitemapGenerator Number Helpers
   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
@@ -40,17 +40,15 @@ 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 = {
@@ -74,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
@@ -93,17 +93,15 @@ 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 = {
@@ -118,37 +116,45 @@ module SitemapGenerator
         }
         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
@@ -160,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
@@ -179,17 +187,15 @@ 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 = {
@@ -208,13 +214,13 @@ module SitemapGenerator
         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)
+        options[:strip_insignificant_zeros] = true unless options.key?(:strip_insignificant_zeros)
 
         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
@@ -231,7 +237,7 @@ module SitemapGenerator
           }
           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

@@ -3,15 +3,11 @@
 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
@@ -28,7 +24,7 @@ module SitemapGenerator
       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 add(*args)
@@ -56,12 +52,12 @@ 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
+      return unless block_given?
+
+      if opts[:yield_sitemap]
+        yield @linkset
+      else
+        instance_eval(&block)
       end
     end
 
@@ -72,11 +68,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