bridgetown-paginate 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d454d6b6a21129a7e91e0297105e6812b8d386eed0f36906fe3eeb84e970f00
-  data.tar.gz: 558c823368a66efc849e0eb32bf3e03c70a167ec39752c7079403a35796798cb
+  metadata.gz: 74e7178bb7fe2835c6d327e53fc515daa42cee491b56fc0a896d9dc2abbacfdf
+  data.tar.gz: 22312d9e2b07d91bb38789b9363ffd542436e6849b364221844b36cebf0f3bb2
 SHA512:
-  metadata.gz: cff6918cd34880a010ef55a24de8578ff585625b4b049bc4480bcf177f9994b06ce7e9199dfa31da05b3f25d4780d0e5e92e413d0cb853fe22b8e12c5a57b062
-  data.tar.gz: efdde8a388ecc0d22887b278c76e16e5291ddf0ae5d74ce2ae4f843f905ba8a446e6499837cfe5b5aca81c4e20f4742e7d2e01e2be1b4d4af4275cf2dec39523
+  metadata.gz: bf6fd86289586aa970c2916caddaeb617fae9c1fc1cdee8c3977b40560f97990a431355a07bff6bc24ebc0b2073916e077203ef48c0a98ec9a0e9c7ba1740e0f
+  data.tar.gz: 917babeb3c44c49e3379acdb36cf613695c6282500b9ef0ff0edfd5c6c71e7db73cc4ecb5f5917de8c15f0ac24238f9b9dc04ad10660b4d8fe63bb9f827303b3

data/lib/bridgetown-paginate.rb

@@ -10,17 +10,16 @@
 require "bridgetown-core"
 require "bridgetown-core/version"
 
-unless ENV["BRIDGETOWN_DISABLE_PAGINATE_GEM"] == "true"
-  module Bridgetown
-    module Paginate
-    end
+module Bridgetown
+  module Paginate
   end
-
-  require "bridgetown-paginate/defaults"
-  require "bridgetown-paginate/utils"
-  require "bridgetown-paginate/pagination_indexer"
-  require "bridgetown-paginate/paginator"
-  require "bridgetown-paginate/pagination_page"
-  require "bridgetown-paginate/pagination_model"
-  require "bridgetown-paginate/pagination_generator"
 end
+
+require "bridgetown-paginate/defaults"
+require "bridgetown-paginate/utils"
+require "bridgetown-paginate/hooks"
+require "bridgetown-paginate/pagination_indexer"
+require "bridgetown-paginate/paginator"
+require "bridgetown-paginate/pagination_page"
+require "bridgetown-paginate/pagination_model"
+require "bridgetown-paginate/pagination_generator"

data/lib/bridgetown-paginate/defaults.rb

@@ -2,31 +2,29 @@
 
 module Bridgetown
   module Paginate
-    module Generator
       # The default configuration for the Paginator
-      DEFAULT = {
-        "enabled"      => false,
-        "collection"   => "posts",
-        "offset"       => 0, # Supports skipping x number of posts from the
-                             # beginning of the post list
-        "per_page"     => 10,
-        "permalink"    => "/page/:num/", # Supports :num as customizable elements
-        "title"        => ":title (Page :num)", # Supports :num as customizable elements
-        "page_num"     => 1,
-        "sort_reverse" => true,
-        "sort_field"   => "date",
-        "limit"        => 0, # Limit how many content objects to paginate (default: 0, means all)
-        "trail"        => {
-          "before" => 0, # Limits how many links to show before the current page
-                         # in the pagination trail (0, means off, default: 0)
-          "after"  => 0, # Limits how many links to show after the current page
-                         # in the pagination trail (0 means off, default: 0)
-        },
-        "indexpage"    => nil, # The default name of the index pages
-        "extension"    => "html", # The default extension for the output pages
-                                  # (ignored if indexpage is nil)
-        "debug"        => false, # Turns on debug output for the gem
-      }.freeze
-    end
+    DEFAULT = {
+      "enabled"      => false,
+      "collection"   => "posts",
+      "offset"       => 0, # Supports skipping x number of posts from the
+                           # beginning of the post list
+      "per_page"     => 10,
+      "permalink"    => "/page/:num/", # Supports :num as customizable elements
+      "title"        => ":title (Page :num)", # Supports :num as customizable elements
+      "page_num"     => 1,
+      "sort_reverse" => true,
+      "sort_field"   => "date",
+      "limit"        => 0, # Limit how many content objects to paginate (default: 0, means all)
+      "trail"        => {
+        "before" => 0, # Limits how many links to show before the current page
+                       # in the pagination trail (0, means off, default: 0)
+        "after"  => 0, # Limits how many links to show after the current page
+                       # in the pagination trail (0 means off, default: 0)
+      },
+      "indexpage"    => nil, # The default name of the index pages
+      "extension"    => "html", # The default extension for the output pages
+                                # (ignored if indexpage is nil)
+      "debug"        => false, # Turns on debug output for the gem
+    }.freeze
   end
 end

data/lib/bridgetown-paginate/hooks.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Bridgetown::Hooks.register :pages, :post_init do |page|
+  if page.class != Bridgetown::Paginate::PaginationPage &&
+      page.site.config.dig("pagination", "enabled") &&
+      page.data.dig("pagination", "enabled")
+    Bridgetown::Paginate::PaginationGenerator.add_matching_template(page)
+  end
+end

data/lib/bridgetown-paginate/pagination_generator.rb

@@ -2,121 +2,131 @@
 
 module Bridgetown
   module Paginate
-    module Generator
-      #
-      # The main entry point into the generator, called by Bridgetown
-      # this function extracts all the necessary information from the Bridgetown
-      # end and passes it into the pagination logic. Additionally it also
-      # contains all site specific actions that the pagination logic needs access
-      # to (such as how to create new pages)
+    #
+    # The main entry point into the generator, called by Bridgetown
+    # this function extracts all the necessary information from the Bridgetown
+    # end and passes it into the pagination logic. Additionally it also
+    # contains all site specific actions that the pagination logic needs access
+    # to (such as how to create new pages)
+    #
+    class PaginationGenerator < Bridgetown::Generator
+      # This generator should be passive with regard to its execution
+      priority :lowest
+
+      @matching_templates = []
+
+      def self.add_matching_template(template)
+        @matching_templates << template
+      end
+
+      class << self
+        attr_reader :matching_templates
+      end
+
+      # Generate paginated pages if necessary (Default entry point)
+      # site - The Site.
       #
-      class PaginationGenerator < Bridgetown::Generator
-        # This generator should be passive with regard to its execution
-        priority :lowest
-
-        # Generate paginated pages if necessary (Default entry point)
-        # site - The Site.
-        #
-        # Returns nothing.
-        def generate(site)
-          # Retrieve and merge the pagination configuration from the site yml file
-          default_config = Bridgetown::Utils.deep_merge_hashes(
-            DEFAULT,
-            site.config["pagination"] || {}
-          )
-
-          # If disabled then simply quit
-          unless default_config["enabled"]
-            Bridgetown.logger.info "Pagination:", "disabled. Enable in site config" \
-              " with pagination:\\n  enabled: true"
-            return
-          end
+      # Returns nothing.
+      def generate(site)
+        # Retrieve and merge the pagination configuration from the site yml file
+        default_config = Bridgetown::Utils.deep_merge_hashes(
+          DEFAULT,
+          site.config["pagination"] || {}
+        )
 
-          Bridgetown.logger.debug "Pagination:", "Starting"
-
-          ################ 0 ####################
-          # Get all pages in the site (this will be used to find the pagination
-          # templates)
-          all_pages = site.pages
-
-          # Get the default title of the site (used as backup when there is no
-          # title available for pagination)
-          site_title = site.data.dig("metadata", "title") || site.config["title"]
-
-          ################ 1 ####################
-          # Specify the callback function that returns the correct docs/posts
-          # based on the collection name
-          # "posts" are just another collection in Bridgetown but a specialized
-          # version that require timestamps
-          # This collection is the default and if the user doesn't specify a
-          # collection in their front-matter then that is the one we load
-          # If the collection is not found then empty array is returned
-          collection_by_name_lambda = lambda do |collection_name|
-            coll = []
-            if collection_name == "all"
-              # the 'all' collection_name is a special case and includes all
-              # collections in the site (except posts!!)
-              # this is useful when you want to list items across multiple collections
-              site.collections.each do |coll_name, coll_data|
-                next unless !coll_data.nil? && coll_name != "posts"
-
-                # Exclude all pagination pages
-                coll += coll_data.docs.reject do |doc|
-                  doc.data.key?("pagination")
-                end
-              end
-            else
-              # Just the one collection requested
-              return [] unless site.collections.key?(collection_name)
+        # If disabled then simply quit
+        unless default_config["enabled"]
+          Bridgetown.logger.info "Pagination:", "disabled. Enable in site config" \
+            " with pagination:\\n  enabled: true"
+          return
+        end
+
+        Bridgetown.logger.debug "Pagination:", "Starting"
+
+        ################ 0 ####################
+        # Get all matching pages in the site found by the init hooks, and ensure they're
+        # still in the site.pages array
+        templates = self.class.matching_templates.select do |page|
+          site.pages.include? page
+        end
+
+        # Get the default title of the site (used as backup when there is no
+        # title available for pagination)
+        site_title = site.data.dig("metadata", "title") || site.config["title"]
+
+        ################ 1 ####################
+        # Specify the callback function that returns the correct docs/posts
+        # based on the collection name
+        # "posts" are just another collection in Bridgetown but a specialized
+        # version that require timestamps
+        # This collection is the default and if the user doesn't specify a
+        # collection in their front-matter then that is the one we load
+        # If the collection is not found then empty array is returned
+        collection_by_name_lambda = lambda do |collection_name|
+          coll = []
+          if collection_name == "all"
+            # the 'all' collection_name is a special case and includes all
+            # collections in the site (except posts!!)
+            # this is useful when you want to list items across multiple collections
+            site.collections.each do |coll_name, coll_data|
+              next unless !coll_data.nil? && coll_name != "posts"
 
               # Exclude all pagination pages
-              coll = site.collections[collection_name].docs.reject do |doc|
+              coll += coll_data.docs.reject do |doc|
                 doc.data.key?("pagination")
               end
             end
-            return coll
-          end
+          else
+            # Just the one collection requested
+            return [] unless site.collections.key?(collection_name)
 
-          ################ 2 ####################
-          # Create the proc that constructs the real-life site page
-          # This is necessary to decouple the code from the Bridgetown site object
-          page_add_lambda = lambda do |newpage|
-            site.pages << newpage # Add the page to the site so that it is generated correctly
-            return newpage # Return the site to the calling code
+            # Exclude all pagination pages
+            coll = site.collections[collection_name].docs.reject do |doc|
+              doc.data.key?("pagination")
+            end
           end
+          return coll
+        end
 
-          ################ 2.5 ####################
-          # lambda that removes a page from the site pages list
-          page_remove_lambda = lambda do |page_to_remove|
-            site.pages.delete_if { |page| page == page_to_remove }
-          end
+        ################ 2 ####################
+        # Create the proc that constructs the real-life site page
+        # This is necessary to decouple the code from the Bridgetown site object
+        page_add_lambda = lambda do |newpage|
+          site.pages << newpage # Add the page to the site so that it is generated correctly
+          return newpage # Return the site to the calling code
+        end
 
-          ################ 3 ####################
-          # Create a proc that will delegate logging
-          # Decoupling Bridgetown specific logging
-          logging_lambda = lambda do |message, type = "info"|
-            if type == "debug"
-              Bridgetown.logger.debug "Pagination:", message.to_s
-            elsif type == "error"
-              Bridgetown.logger.error "Pagination:", message.to_s
-            elsif type == "warn"
-              Bridgetown.logger.warn "Pagination:", message.to_s
-            else
-              Bridgetown.logger.info "Pagination:", message.to_s
-            end
-          end
+        ################ 2.5 ####################
+        # lambda that removes a page from the site pages list
+        page_remove_lambda = lambda do |page_to_remove|
+          site.pages.delete_if { |page| page == page_to_remove }
+        end
 
-          ################ 4 ####################
-          # Now create and call the model with the real-life page creation proc and site data
-          model = PaginationModel.new(
-            logging_lambda,
-            page_add_lambda,
-            page_remove_lambda,
-            collection_by_name_lambda
-          )
-          count = model.run(default_config, all_pages, site_title)
-          Bridgetown.logger.info "Pagination:", "Complete, processed #{count} pagination page(s)"
+        ################ 3 ####################
+        # Create a proc that will delegate logging
+        # Decoupling Bridgetown specific logging
+        logging_lambda = lambda do |message, type = "info"|
+          if type == "debug"
+            Bridgetown.logger.debug "Pagination:", message.to_s
+          elsif type == "error"
+            Bridgetown.logger.error "Pagination:", message.to_s
+          elsif type == "warn"
+            Bridgetown.logger.warn "Pagination:", message.to_s
+          else
+            Bridgetown.logger.info "Pagination:", message.to_s
+          end
         end
+
+        ################ 4 ####################
+        # Now create and call the model with the real-life page creation proc and site data
+        model = PaginationModel.new(
+          logging_lambda,
+          page_add_lambda,
+          page_remove_lambda,
+          collection_by_name_lambda
+        )
+        count = model.run(default_config, templates, site_title)
+        Bridgetown.logger.info "Pagination:", "Complete, processed #{count} pagination page(s)"
       end
     end
   end

data/lib/bridgetown-paginate/pagination_indexer.rb

@@ -2,111 +2,123 @@
 
 module Bridgetown
   module Paginate
-    module Generator
+    #
+    # Performs indexing of the posts or collection documents as well as
+    # filtering said collections when requested by the defined filters.
+    #
+    class PaginationIndexer
+      @cached_index = {}
+
+      class << self
+        attr_accessor :cached_index
+      end
+
       #
-      # Performs indexing of the posts or collection documents as well as
-      # filtering said collections when requested by the defined filters.
+      # Create a hash index for all documents based on a key in the
+      # document.data table
       #
-      class PaginationIndexer
-        #
-        # Create a hash index for all documents based on a key in the
-        # document.data table
-        #
-        def self.index_documents_by(all_documents, index_key)
-          return nil if all_documents.nil?
-          return all_documents if index_key.nil?
-
-          # Where queries are a key/value pair, so grab the first key element
-          index_key = index_key[0] if index_key.is_a?(Array)
-
-          index = {}
-          all_documents.each do |document|
-            next if document.data.nil?
-            next unless document.data.key?(index_key)
-            next if document.data[index_key].nil?
-            next if document.data[index_key].size <= 0
-            next if document.data[index_key].to_s.strip.empty?
-
-            # Only tags and categories come as premade arrays, locale does not,
-            # so convert any data elements that are strings into arrays
-            document_data = document.data[index_key]
-            document_data = document_data.split(%r!;|,!) if document_data.is_a?(String)
-
-            document_data.each do |key|
-              key = key.to_s.downcase.strip
-              # If the key is a delimetered list of values
-              # (meaning the user didn't use an array but a string with commas)
-              key.split(%r!;|,!).each do |k_split|
-                k_split = k_split.to_s.downcase.strip # Clean whitespace and junk
-                index[k_split.to_s] = [] unless index.key?(k_split)
-                index[k_split.to_s] << document
-              end
-            end
-          end
+      def self.index_documents_by(all_documents, index_key)
+        return nil if all_documents.nil?
+        return all_documents if index_key.nil?
+
+        # Where queries are a key/value pair, so grab the first key element
+        index_key = index_key[0] if index_key.is_a?(Array)
 
-          index
+        if (found_index = cached_index.dig(all_documents.object_id, index_key))
+          return found_index
         end
 
-        #
-        # Creates an intersection (only returns common elements)
-        # between multiple arrays
-        #
-        def self.intersect_arrays(first, *rest)
-          return nil if first.nil?
-          return nil if rest.nil?
+        index = {}
+        all_documents.each do |document|
+          next if document.data.nil?
+          next unless document.data.key?(index_key)
+          next if document.data[index_key].nil?
+          next if document.data[index_key].size <= 0
+          next if document.data[index_key].to_s.strip.empty?
 
-          intersect = first
-          rest.each do |item|
-            return [] if item.nil?
+          # Only tags and categories come as premade arrays, locale does not,
+          # so convert any data elements that are strings into arrays
+          document_data = document.data[index_key]
+          document_data = document_data.split(%r!;|,!) if document_data.is_a?(String)
 
-            intersect &= item
+          document_data.each do |key|
+            key = key.to_s.downcase.strip
+            # If the key is a delimetered list of values
+            # (meaning the user didn't use an array but a string with commas)
+            key.split(%r!;|,!).each do |k_split|
+              k_split = k_split.to_s.downcase.strip # Clean whitespace and junk
+              index[k_split.to_s] = [] unless index.key?(k_split)
+              index[k_split.to_s] << document
+            end
           end
+        end
 
-          intersect
+        unless cached_index[all_documents.object_id].is_a?(Hash)
+          cached_index[all_documents.object_id] = {}
         end
+        cached_index[all_documents.object_id][index_key] = index
+        index
+      end
 
-        # Filters documents based on a keyed source_documents hash of indexed
-        # documents and performs a intersection of the two sets. Returns only
-        # documents that are common between all collections
-        def self.read_config_value_and_filter_documents(
-          config,
-          config_key,
-          documents,
-          source_documents
-        )
-          return nil if documents.nil?
-
-          # If the source is empty then simply don't do anything
-          return nil if source_documents.nil?
-
-          return documents if config.nil?
-          return documents unless config.key?(config_key)
-          return documents if config[config_key].nil?
-
-          # Get the filter values from the config (this is the cat/tag/locale
-          # values that should be filtered on)
-          config_value = config[config_key]
-
-          # Use the second key/value element if it's a "where query"
-          config_value = config_value[1] if config_key == "where_query"
-
-          # If we're dealing with a delimitered string instead of an array then
-          # let's be forgiving
-          config_value = config_value.split(%r!;|,!) if config_value.is_a?(String)
-
-          # Now for all filter values for the config key, let's remove all items
-          # from the documents that aren't common for all collections that the
-          # user wants to filter on
-          # TODO: right now this is an "AND" operation if multiple keys are present.
-          # Should offer the ability to do an OR operation instead.
-          config_value.each do |key|
-            key = key.to_s.downcase.strip
-            documents = PaginationIndexer.intersect_arrays(documents, source_documents[key])
-          end
+      #
+      # Creates an intersection (only returns common elements)
+      # between multiple arrays
+      #
+      def self.intersect_arrays(first, *rest)
+        return nil if first.nil?
+        return nil if rest.nil?
 
-          # The fully filtered final document list
-          documents
+        intersect = first
+        rest.each do |item|
+          return [] if item.nil?
+
+          intersect &= item
         end
+
+        intersect
+      end
+
+      # Filters documents based on a keyed source_documents hash of indexed
+      # documents and performs a intersection of the two sets. Returns only
+      # documents that are common between all collections
+      def self.read_config_value_and_filter_documents(
+        config,
+        config_key,
+        documents,
+        source_documents
+      )
+        return nil if documents.nil?
+
+        # If the source is empty then simply don't do anything
+        return nil if source_documents.nil?
+
+        return documents if config.nil?
+        return documents unless config.key?(config_key)
+        return documents if config[config_key].nil?
+
+        # Get the filter values from the config (this is the cat/tag/locale
+        # values that should be filtered on)
+        config_value = config[config_key]
+
+        # Use the second key/value element if it's a "where query"
+        config_value = config_value[1] if config_key == "where_query"
+
+        # If we're dealing with a delimitered string instead of an array then
+        # let's be forgiving
+        config_value = config_value.split(%r!;|,!) if config_value.is_a?(String)
+
+        # Now for all filter values for the config key, let's remove all items
+        # from the documents that aren't common for all collections that the
+        # user wants to filter on
+        # TODO: right now this is an "AND" operation if multiple keys are present.
+        # Should offer the ability to do an OR operation instead.
+        config_value.each do |key|
+          key = key.to_s.downcase.strip
+          documents = PaginationIndexer.intersect_arrays(documents, source_documents[key])
+        end
+
+        # The fully filtered final document list
+        documents
       end
     end
   end