sitemap_generator_ftbpro 5.0.4

data/lib/sitemap_generator/builder/sitemap_url.rb

@@ -0,0 +1,250 @@
+require 'builder'
+require 'uri'
+require 'time'
+require 'date'
+
+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
+
+      # Return a new instance with options configured on it.
+      #
+      # == Arguments
+      # * sitemap - a Sitemap instance, or
+      # * path, options - a path string and options hash
+      #
+      # == Options
+      # Requires a host to be set.  If passing a sitemap, the sitemap must have a +default_host+
+      # configured.  If calling with a path and options, you must include the <tt>:host</tt> option.
+      #
+      # * +host+
+      # * +priority+
+      # * +changefreq+
+      # * +lastmod+
+      # * +images+
+      # * +video+/+videos+
+      # * +geo+
+      # * +news+
+      # * +mobile+
+      # * +alternate+/+alternates+
+      # * +pagemap+
+      def initialize(path, options={})
+        options = options.dup
+        if sitemap = path.is_a?(SitemapGenerator::Builder::SitemapFile) && path
+          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, :expires, :host, :images, :video, :geo, :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 => [])
+        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
+        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],
+          :geo        => options[:geo],
+          :mobile     => options[:mobile],
+          :alternates => options[:alternates],
+          :pagemap    => options[:pagemap]
+        )
+      end
+
+      # Return the URL as XML
+      def to_xml(builder=nil)
+        builder = ::Builder::XmlMarkup.new if builder.nil?
+        builder.url do
+          builder.loc        self[:loc]
+          builder.lastmod    w3c_date(self[:lastmod])      if self[:lastmod]
+          builder.expires    w3c_date(self[:expires])      if self[:expires]
+          builder.changefreq self[:changefreq].to_s        if self[:changefreq]
+          builder.priority   format_float(self[:priority]) if self[:priority]
+
+          unless SitemapGenerator::Utilities.blank?(self[:news])
+            news_data = self[:news]
+            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
+
+              builder.news :access, news_data[:access].to_s if news_data[:access]
+              builder.news :genres, news_data[:genres].to_s if news_data[:genres]
+              builder.news :publication_date, w3c_date(news_data[:publication_date]) if news_data[:publication_date]
+              builder.news :title, news_data[:title].to_s if news_data[:title]
+              builder.news :keywords, news_data[:keywords].to_s if news_data[:keywords]
+              builder.news :stock_tickers, news_data[:stock_tickers].to_s if news_data[:stock_tickers]
+            end
+          end
+
+          self[:images].each do |image|
+            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]
+              builder.image :title, image[:title].to_s                 if image[:title]
+              builder.image :license, image[:license].to_s             if image[:license]
+            end
+          end
+
+          self[:videos].each do |video|
+            builder.video :video do
+              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])
+                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 :publication_date, w3c_date(video[:publication_date]) if video[:publication_date]
+              video[:tags].each {|tag| builder.video :tag, tag.to_s }        if video[:tags]
+              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[:uploader]
+                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.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, :hreflang => alternate[:lang].to_s, :href => alternate[:href].to_s }
+            attributes[:media] = alternate[:media].to_s if SitemapGenerator::Utilities.present?(alternate[:media])
+            builder.xhtml :link, attributes
+          end
+
+          unless SitemapGenerator::Utilities.blank?(self[:geo])
+            geo = self[:geo]
+            builder.geo :geo do
+              builder.geo :format, geo[:format].to_s if geo[:format]
+            end
+          end
+
+          unless SitemapGenerator::Utilities.blank?(self[:mobile])
+            builder.mobile :mobile
+          end
+
+          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
+                  SitemapGenerator::Utilities.as_array(dataobject[:attributes]).each do |attribute|
+                    builder.pagemap :Attribute, attribute[:value].to_s, :name => attribute[:name].to_s
+                  end
+                end
+              end
+            end
+          end
+        end
+        builder << '' # Force to string
+      end
+
+      def news?
+        SitemapGenerator::Utilities.present?(self[:news])
+      end
+
+      protected
+
+      def prepare_video_price_attribs(video)
+        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])
+        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?
+        news
+      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.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)]
+      end
+
+      def w3c_date(date)
+        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")
+        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
+
+          if zulutime
+            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
+          end
+        end
+      end
+
+      # Accept a string or boolean and return 'yes' or 'no'.  If a string, the
+      # 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
+          value.downcase
+        else
+          value ? 'yes' : 'no'
+        end
+      end
+
+      # If the value is nil, return `default` converted to either 'yes' or 'no'.
+      # If the value is set, return its value converted to 'yes' or 'no'.
+      def yes_or_no_with_default(value, default)
+        yes_or_no(value.nil? ? default : value)
+      end
+
+      # 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)
+      end
+    end
+  end
+end

data/lib/sitemap_generator/builder.rb

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

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/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/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

data/lib/sitemap_generator/interpreter.rb

@@ -0,0 +1,80 @@
+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.rails3?
+      include ::Rails.application.routes.url_helpers
+    elsif SitemapGenerator.app.rails?
+      require 'action_controller'
+      include ActionController::UrlWriter
+    end
+
+    # Call with a block to evaluate a dynamic config.  The only method exposed for you is
+    # `add` to add a link to the sitemap object attached to this interpreter.
+    #
+    # === Options
+    # * <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)
+      @linkset = opts.delete :link_set
+      @linkset.send(:set_options, opts)
+      eval(&block) if block_given?
+    end
+
+    def add(*args)
+      @linkset.add(*args)
+    end
+
+    def add_to_index(*args)
+      @linkset.add_to_index(*args)
+    end
+    
+    # Start a new group of sitemaps.  Any of the options to SitemapGenerator.new may
+    # be passed.  Pass a block with calls to +add+ to add links to the sitemaps.
+    #
+    # All groups use the same sitemap index.
+    def group(*args, &block)
+      @linkset.group(*args, &block)
+    end
+
+    # Return the LinkSet instance so that you can access it from within the `create` block
+    # without having to use the yield_sitemap option.
+    def sitemap
+      @linkset
+    end
+
+    # 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
+      end
+    end
+
+    # Run the interpreter on a config file using
+    # the default <tt>SitemapGenerator::Sitemap</tt> sitemap object.
+    #
+    # === Options
+    # * <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)
+      opts = opts.dup
+      config_file = opts.delete(:config_file)
+      config_file ||= SitemapGenerator.app.root + 'config/sitemap.rb'
+      interpreter = self.new(opts)
+      interpreter.instance_eval(File.read(config_file), config_file.to_s)
+      interpreter
+    end
+  end
+end