sitemap_generator 2.2.1 → 3.0.0

data/VERSION

@@ -1 +1 @@
-2.2.1
+3.0.0

data/lib/sitemap_generator.rb

@@ -6,24 +6,25 @@ require 'sitemap_generator/utilities'
 require 'sitemap_generator/application'
 require 'sitemap_generator/adapters'
 require 'sitemap_generator/sitemap_location'
-require 'active_support/core_ext/numeric'
 
 module SitemapGenerator
   autoload(:Interpreter, 'sitemap_generator/interpreter')
   autoload(:FileAdapter, 'sitemap_generator/adapters/file_adapter')
   autoload(:WaveAdapter, 'sitemap_generator/adapters/wave_adapter')
+  autoload(:BigDecimal,  'sitemap_generator/core_ext/big_decimal')
+  autoload(:Numeric,     'sitemap_generator/core_ext/numeric')
 
-  SitemapError = Class.new(StandardError)
-  SitemapFullError = Class.new(SitemapError)
+  SitemapError          = Class.new(StandardError)
+  SitemapFullError      = Class.new(SitemapError)
   SitemapFinalizedError = Class.new(SitemapError)
 
-  silence_warnings do
+  Utilities.with_warnings(nil) do
     VERSION = File.read(File.dirname(__FILE__) + "/../VERSION").strip
     MAX_SITEMAP_FILES    = 50_000        # max sitemap links per index file
     MAX_SITEMAP_LINKS    = 50_000        # max links per sitemap
     MAX_SITEMAP_IMAGES   = 1_000         # max images per url
     MAX_SITEMAP_NEWS     = 1_000         # max news sitemap per index_file
-    MAX_SITEMAP_FILESIZE = 10.megabytes  # bytes
+    MAX_SITEMAP_FILESIZE = SitemapGenerator::Numeric.new(10).megabytes  # bytes
 
     # Lazy-initialize the LinkSet instance
     Sitemap = (Class.new do
@@ -40,7 +41,22 @@ module SitemapGenerator
 
   class << self
     attr_accessor :root, :app, :templates
-    attr_writer :yield_sitemap
+    attr_writer :yield_sitemap, :verbose
+  end
+
+  # Global default for the verbose setting.
+  def self.verbose
+    if @verbose.nil?
+      @verbose = if SitemapGenerator::Utilities.truthy?(ENV['VERBOSE'])
+        true
+      elsif SitemapGenerator::Utilities.falsy?(ENV['VERBOSE'])
+        false
+      else
+        nil
+      end
+    else
+      @verbose
+    end
   end
 
   # Returns true if we should yield the sitemap instance to the block, false otherwise.
@@ -48,9 +64,9 @@ module SitemapGenerator
     !!@yeild_sitemap
   end
 
-  self.root = File.expand_path(File.join(File.dirname(__FILE__), '../'))
+  self.root      = File.expand_path(File.join(File.dirname(__FILE__), '../'))  # Root of the install dir, not the Rails app
   self.templates = SitemapGenerator::Templates.new(self.root)
-  self.app = SitemapGenerator::Application.new
+  self.app       = SitemapGenerator::Application.new
 end
 
 require 'sitemap_generator/railtie' if SitemapGenerator.app.rails3?

data/lib/sitemap_generator/application.rb

@@ -8,15 +8,42 @@ module SitemapGenerator
 
     # Returns a boolean indicating whether this environment is Rails 3
     #
-    # @return [Boolean]    
+    # @return [Boolean]
     def rails3?
       rails? && Rails.version.to_f >= 3
     rescue
       false # Rails.version defined in 2.1.0
     end
-   
+
     def root
-      Pathname.new(rails? && Rails.root || Dir.getwd)
+      Pathname.new(rails_root || Dir.getwd)
+    end
+
+    protected
+
+    # Returns the root of the Rails application,
+    # if this is running in a Rails context.
+    # Returns `nil` if no such root is defined.
+    #
+    # @return [String, nil]
+    def rails_root
+      if defined?(::Rails.root)
+        return ::Rails.root.to_s if ::Rails.root
+        raise "ERROR: Rails.root is nil!"
+      end
+      return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+      return nil
+    end
+
+    # Returns the environment of the Rails application,
+    # if this is running in a Rails context.
+    # Returns `nil` if no such environment is defined.
+    #
+    # @return [String, nil]
+    def rails_env
+      return ::Rails.env.to_s if defined?(::Rails.env)
+      return RAILS_ENV.to_s if defined?(RAILS_ENV)
+      return nil
     end
   end
-end
+end

data/lib/sitemap_generator/builder.rb

@@ -2,9 +2,3 @@ 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
-  module Builder
-
-  end
-end

data/lib/sitemap_generator/builder/sitemap_file.rb

@@ -1,6 +1,6 @@
 require 'zlib'
-require 'action_view' # for number_to_human_size
 require 'fileutils'
+require 'sitemap_generator/helpers/number_helper'
 
 module SitemapGenerator
   module Builder
@@ -12,8 +12,7 @@ module SitemapGenerator
     #   sitemap.finalize!            <- write the sitemap file and freeze the object to protect it from further modification
     #
     class SitemapFile
-      include ActionView::Helpers::NumberHelper
-      include ActionView::Helpers::TextHelper   # Rails 2.2.2 fails with missing 'pluralize' otherwise
+      include SitemapGenerator::Helpers::NumberHelper
       attr_reader :link_count, :filesize, :location, :news_count
 
       # === Options
@@ -125,13 +124,24 @@ module SitemapGenerator
 
       # Return a summary string
       def summary(opts={})
-        uncompressed_size = number_to_human_size(@filesize) rescue "#{@filesize / 8} KB"
-        compressed_size =   number_to_human_size(@location.filesize) rescue "#{@location.filesize / 8} KB"
-        "+ #{'%-21s' % @location.path_in_public} #{'%13s' % @link_count} links / #{'%10s' % uncompressed_size} / #{'%10s' % compressed_size} gzipped"
+        uncompressed_size = number_to_human_size(@filesize)
+        compressed_size   = number_to_human_size(@location.filesize)
+        path = ellipsis(@location.path_in_public, 47)
+        "+ #{'%-47s' % path} #{'%10s' % @link_count} links / #{'%10s' % compressed_size}"
       end
 
       protected
 
+      # Replace the last 3 characters of string with ... if the string is as big
+      # or bigger than max.
+      def ellipsis(string, max)
+        if string.size >= max
+          string[0, max - 3] + '...'
+        else
+          string
+        end
+      end
+
       # Return the bytesize length of the string.  Ruby 1.8.6 compatible.
       def bytesize(string)
         string.respond_to?(:bytesize) ? string.bytesize : string.length

data/lib/sitemap_generator/builder/sitemap_index_file.rb

@@ -49,9 +49,10 @@ module SitemapGenerator
 
       # Return a summary string
       def summary(opts={})
-        uncompressed_size = number_to_human_size(@filesize) rescue "#{@filesize / 8} KB"
-        compressed_size =   number_to_human_size(@location.filesize) rescue "#{@location.filesize / 8} KB"
-        "+ #{'%-21s' % @location.path_in_public} #{'%10s' % @link_count} sitemaps / #{'%10s' % uncompressed_size} / #{'%10s' % compressed_size} gzipped"
+        uncompressed_size = number_to_human_size(@filesize)
+        compressed_size =   number_to_human_size(@location.filesize)
+        path = ellipsis(@location.path_in_public, 44) # 47 - 3
+        "+ #{'%-44s' % path} #{'%10s' % @link_count} sitemaps / #{'%10s' % compressed_size}"
       end
 
       def stats_summary(opts={})

data/lib/sitemap_generator/builder/sitemap_index_url.rb

@@ -6,7 +6,7 @@ module SitemapGenerator
 
       def initialize(path, options={})
         if index = path.is_a?(SitemapGenerator::Builder::SitemapIndexFile) && path
-          options.reverse_merge!(:host => index.location.host, :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
+          SitemapGenerator::Utilities.reverse_merge!(options, :host => index.location.host, :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
           path = index.location.path_in_public
           super(path, options)
         else

data/lib/sitemap_generator/builder/sitemap_url.rb

@@ -28,15 +28,13 @@ module SitemapGenerator
       # * +news+
       def initialize(path, options={})
         if sitemap = path.is_a?(SitemapGenerator::Builder::SitemapFile) && path
-          options.reverse_merge!(:host => sitemap.location.host, :lastmod => sitemap.lastmod)
+          SitemapGenerator::Utilities.reverse_merge!(options, :host => sitemap.location.host, :lastmod => sitemap.lastmod)
           path = sitemap.location.path_in_public
         end
 
         SitemapGenerator::Utilities.assert_valid_keys(options, :priority, :changefreq, :lastmod, :host, :images, :video, :geo, :news, :videos)
-        options.reverse_merge!(:priority => 0.5, :changefreq => 'weekly', :lastmod => Time.now, :images => [], :news => {}, :videos => [])
-        if options[:host].blank?
-          raise "Cannot generate a url without a host"
-        end
+        SitemapGenerator::Utilities.reverse_merge!(options, :priority => 0.5, :changefreq => 'weekly', :lastmod => Time.now, :images => [], :news => {}, :videos => [])
+        raise "Cannot generate a url without a host" unless SitemapGenerator::Utilities.present?(options[:host])
         if video = options.delete(:video)
           options[:videos] = video.is_a?(Array) ? options[:videos].concat(video) : options[:videos] << video
         end
@@ -65,7 +63,7 @@ module SitemapGenerator
           builder.changefreq self[:changefreq]             if self[:changefreq]
           builder.priority   format_float(self[:priority]) if self[:priority]
 
-          unless self[:news].blank?
+          unless SitemapGenerator::Utilities.blank?(self[:news])
             news_data = self[:news]
             builder.news:news do
               builder.news:publication do
@@ -117,7 +115,7 @@ module SitemapGenerator
             end
           end
 
-          unless self[:geo].blank?
+          unless SitemapGenerator::Utilities.blank?(self[:geo])
             geo = self[:geo]
             builder.geo :geo do
               builder.geo :format, geo[:format] if geo[:format]
@@ -128,7 +126,7 @@ module SitemapGenerator
       end
 
       def news?
-        self[:news].present?
+        SitemapGenerator::Utilities.present?(self[:news])
       end
 
       protected

data/lib/sitemap_generator/core_ext.rb

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

data/lib/sitemap_generator/core_ext/big_decimal.rb

@@ -0,0 +1,45 @@
+require 'bigdecimal'
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'yaml'
+
+# Define our own class rather than modify the global class
+class SitemapGenerator::BigDecimal < BigDecimal
+  YAML_TAG = 'tag:yaml.org,2002:float'
+  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
+
+  yaml_as YAML_TAG
+
+  # 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 if 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
+
+  def encode_with(coder)
+    string = to_s
+    coder.represent_scalar(nil, YAML_MAPPING[string] || string)
+  end
+
+  def to_d
+    self
+  end
+
+  DEFAULT_STRING_FORMAT = 'F'
+  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
+    _original_to_s(format)
+  end
+  alias_method :_original_to_s, :to_s
+  alias_method :to_s, :to_formatted_s
+end

data/lib/sitemap_generator/core_ext/numeric.rb

@@ -0,0 +1,48 @@
+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
+  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

@@ -0,0 +1,237 @@
+# require "sitemap_generator/core_ext/big_decimal/conversions"
+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
+
+      # 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)
+          @number = number
+        end
+      end
+
+      # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
+      # customize the format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:locale</tt>     - Sets the locale to be used for formatting (defaults to current locale).
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+      # * <tt>:separator</tt>  - Sets the separator between the fractional and integer digits (defaults to ".").
+      #
+      # ==== Examples
+      #  number_with_delimiter(12345678)                        # => 12,345,678
+      #  number_with_delimiter(12345678.05)                     # => 12,345,678.05
+      #  number_with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
+      #  number_with_delimiter(12345678, :separator => ",")     # => 12,345,678
+      #  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 = {})
+        SitemapGenerator::Utilities.symbolize_keys!(options)
+
+        begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults = {
+          :separator => ".",
+          :delimiter => ",",
+          :precision => 3,
+          :significant => false,
+          :strip_insignificant_zeros => false
+        }
+        options = SitemapGenerator::Utilities.reverse_merge(options, defaults)
+
+        parts = number.to_s.to_str.split('.')
+        parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
+        parts.join(options[:separator])
+      end
+
+      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision
+      # of 2 if +:significant+ is +false+, and 5 if +:significant+ is +true+).
+      # You can customize the format in the +options+ hash.
+      #
+      # ==== 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>: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+)
+      #
+      # ==== Examples
+      #  number_with_precision(111.2345)                                            # => 111.235
+      #  number_with_precision(111.2345, :precision => 2)                           # => 111.23
+      #  number_with_precision(13, :precision => 5)                                 # => 13.00000
+      #  number_with_precision(389.32314, :precision => 0)                          # => 389
+      #  number_with_precision(111.2345, :significant => true)                      # => 111
+      #  number_with_precision(111.2345, :precision => 1, :significant => true)     # => 100
+      #  number_with_precision(13, :precision => 5, :significant => true)           # => 13.000
+      #  number_with_precision(111.234, :locale => :fr)                             # => 111,234
+      #  number_with_precision(13, :precision => 5, :significant => true, strip_insignificant_zeros => true)
+      #  # => 13
+      #  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 = {})
+        SitemapGenerator::Utilities.symbolize_keys!(options)
+
+        number = begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults = {
+          :separator => ".",
+          :delimiter => ",",
+          :precision => 3,
+          :significant => false,
+          :strip_insignificant_zeros => false
+        }
+        precision_defaults = {
+          :delimiter => ""
+        }
+        defaults = defaults.merge(precision_defaults)
+
+        options = SitemapGenerator::Utilities.reverse_merge(options, defaults)  # Allow the user to unset default values: Eg.: :significant => false
+        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
+          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)
+            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
+        else
+          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)
+        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
+
+      # Formats the bytes in +number+ into a more understandable representation
+      # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
+      # reporting file sizes to users. You can customize the
+      # format in the +options+ hash.
+      #
+      # See <tt>number_to_human</tt> if you want to pretty-print a generic number.
+      #
+      # ==== 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>: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+)
+      # ==== Examples
+      #  number_to_human_size(123)                                          # => 123 Bytes
+      #  number_to_human_size(1234)                                         # => 1.21 KB
+      #  number_to_human_size(12345)                                        # => 12.1 KB
+      #  number_to_human_size(1234567)                                      # => 1.18 MB
+      #  number_to_human_size(1234567890)                                   # => 1.15 GB
+      #  number_to_human_size(1234567890123)                                # => 1.12 TB
+      #  number_to_human_size(1234567, :precision => 2)                     # => 1.2 MB
+      #  number_to_human_size(483989, :precision => 2)                      # => 470 KB
+      #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,2 MB
+      #
+      # Non-significant zeros after the fractional separator are stripped out by default (set
+      # <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 = {})
+        SitemapGenerator::Utilities.symbolize_keys!(options)
+
+        number = begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults = {
+          :separator => ".",
+          :delimiter => ",",
+          :precision => 3,
+          :significant => false,
+          :strip_insignificant_zeros => false
+        }
+        human = {
+          :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)
+
+        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)
+        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
+
+          unit_key = STORAGE_UNITS[exponent]
+          units = {
+            :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)
+        end
+      end
+    end
+  end
+end