ftbpro_sitemap_generator 5.0.8

data/lib/sitemap_generator/builder/sitemap_index_file.rb

@@ -0,0 +1,149 @@
+module SitemapGenerator
+  module Builder
+    class SitemapIndexFile < SitemapFile
+
+      # === Options
+      #
+      # * <tt>location</tt> - a SitemapGenerator::SitemapIndexLocation instance or a Hash of options
+      #   from which a SitemapLocation will be created for you.
+      def initialize(opts={})
+        @location = opts.is_a?(Hash) ? SitemapGenerator::SitemapIndexLocation.new(opts) : opts
+        @link_count = 0
+        @sitemaps_link_count = 0
+        @xml_content = '' # XML urlset content
+        @xml_wrapper_start = <<-HTML
+          <?xml version="1.0" encoding="UTF-8"?>
+            <sitemapindex
+              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+              xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
+                http://www.sitemaps.org/schemas/sitemap/0.9/siteindex.xsd"
+              xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+            >
+        HTML
+        @xml_wrapper_start.gsub!(/\s+/, ' ').gsub!(/ *> */, '>').strip!
+        @xml_wrapper_end   = %q[</sitemapindex>]
+        @filesize = SitemapGenerator::Utilities.bytesize(@xml_wrapper_start) + SitemapGenerator::Utilities.bytesize(@xml_wrapper_end)
+        @written = false
+        @reserved_name = nil # holds the name reserved from the namer
+        @frozen = false      # rather than actually freeze, use this boolean
+        @first_sitemap = nil # reference to the first thing added to this index
+        # Store the URL of the first sitemap added because if create_index is
+        # false this is the "index" URL
+        @first_sitemap_url = nil
+      end
+
+      # Finalize sitemaps as they are added to the index.
+      # If it's the first sitemap, finalize it but don't
+      # write it out, because we don't yet know if we need an index.  If it's
+      # the second sitemap, we know we need an index, so reserve a name for the
+      # index, and go and write out the first sitemap.  If it's the third or
+      # greater sitemap, just finalize and write it out as usual, nothing more
+      # needs to be done.
+      #
+      # If a link is being added to the index manually as a string, then we
+      # can assume that the index is required (unless create_index is false of course).
+      # This seems like the logical thing to do.
+      alias_method :super_add, :add
+      def add(link, options={})
+        if file = link.is_a?(SitemapFile) && link
+          @sitemaps_link_count += file.link_count
+          file.finalize! unless file.finalized?
+
+          # First link.  If it's a SitemapFile store a reference to it and the options
+          # so that we can create a URL from it later.  We can't create the URL yet
+          # because doing so fixes the sitemap file's name, and we have to wait to see
+          # if we have more than one link in the index before we can know who gets the
+          # first name (the index, or the sitemap).  If the item is not a SitemapFile,
+          # then it has been manually added and we can be sure that the user intends
+          # for there to be an index.
+          if @link_count == 0
+            @first_sitemap = SitemapGenerator::Builder::LinkHolder.new(file, options)
+            @link_count += 1     # pretend it's added, but don't add it yet
+          else
+            # need an index so make sure name is reserved and first sitemap is written out
+            reserve_name unless @location.create_index == false
+            write_first_sitemap
+            file.write
+            super(SitemapGenerator::Builder::SitemapIndexUrl.new(file, options))
+          end
+        else
+          # A link is being added manually.  Obviously the user wants an index.
+          # This overrides the create_index setting.
+          unless @location.create_index == false
+            @create_index = true
+            reserve_name
+          end
+
+          # Use the host from the location if none provided
+          options[:host] ||= @location.host
+          super(SitemapGenerator::Builder::SitemapIndexUrl.new(link, options))
+        end
+      end
+
+      # Return a boolean indicating whether the sitemap file can fit another link
+      # of <tt>bytes</tt> bytes in size.  You can also pass a string and the
+      # bytesize will be calculated for you.
+      def file_can_fit?(bytes)
+        bytes = bytes.is_a?(String) ? SitemapGenerator::Utilities.bytesize(bytes) : bytes
+        (@filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE && @link_count < SitemapGenerator::MAX_SITEMAP_FILES
+      end
+
+      # Return the total number of links in all sitemaps reference by this index file
+      def total_link_count
+        @sitemaps_link_count
+      end
+
+      def stats_summary(opts={})
+        str = "Sitemap stats: #{number_with_delimiter(@sitemaps_link_count)} links / #{@link_count} sitemaps"
+        str += " / %dm%02ds" % opts[:time_taken].divmod(60) if opts[:time_taken]
+      end
+
+      def finalize!
+        raise SitemapGenerator::SitemapFinalizedError if finalized?
+        reserve_name if create_index?
+        write_first_sitemap
+        @frozen = true
+      end
+
+      # Write out the index if an index is needed
+      def write
+        super if create_index?
+      end
+
+      # Whether or not we need to create an index file.  True if create_index is true
+      # or if create_index is :auto and we have more than one link in the index.
+      # If a link is added manually and create_index is not false, we force index
+      # creation because they obviously intend for there to be an index.  False otherwise.
+      def create_index?
+        @create_index || @location.create_index == true || @location.create_index == :auto && @link_count > 1
+      end
+
+      # Return the index file URL.  If create_index is true, this is the URL
+      # of the actual index file.  If create_index is false, this is the URL
+      # of the first sitemap that was written out.  Only call this method
+      # *after* the files have been finalized.
+      def index_url
+        if create_index? || !@first_sitemap_url
+          @location.url
+        else
+          @first_sitemap_url
+        end
+      end
+
+      protected
+
+      # Make sure the first sitemap has been written out and added to the index
+      def write_first_sitemap
+        if @first_sitemap
+          @first_sitemap.link.write unless @first_sitemap.link.written?
+          super_add(SitemapGenerator::Builder::SitemapIndexUrl.new(@first_sitemap.link, @first_sitemap.options))
+          @link_count -= 1   # we already counted it, don't count it twice
+          # Store the URL because if create_index is false, this is the
+          # "index" URL
+          @first_sitemap_url = @first_sitemap.link.location.url
+          @first_sitemap = nil
+        end
+      end
+    end
+  end
+end

data/lib/sitemap_generator/builder/sitemap_index_url.rb

@@ -0,0 +1,28 @@
+require 'builder'
+
+module SitemapGenerator
+  module Builder
+    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, :changefreq => 'always', :priority => 1.0)
+          path = index.location.path_in_public
+          super(path, options)
+        else
+          super
+        end
+      end
+
+      # Return the URL as XML
+      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]
+        end
+        builder << '' # force to string
+      end
+    end
+  end
+end

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