jekyll-paginate-v2 1.5.0 → 1.5.1

data/lib/jekyll-paginate-v2/generator/paginationIndexer.rb

@@ -0,0 +1,93 @@
+module Jekyll
+  module PaginateV2::Generator
+
+    # 
+    # Performs indexing of the posts or collection documents
+    # as well as filtering said collections when requested by the defined filters.
+    class PaginationIndexer
+      #
+      # Create a hash index for all post based on a key in the post.data table
+      #
+      def self.index_posts_by(all_posts, index_key)
+        return nil if all_posts.nil?
+        return all_posts if index_key.nil?
+        index = {}
+        for post in all_posts
+          next if post.data.nil?
+          next if !post.data.has_key?(index_key)
+          next if post.data[index_key].nil?
+          next if post.data[index_key].size <= 0
+          next if post.data[index_key].to_s.strip.length == 0
+          
+          # Only tags and categories come as premade arrays, locale does not, so convert any data
+          # elements that are strings into arrays
+          post_data = post.data[index_key]
+          if post_data.is_a?(String)
+            post_data = post_data.split(/;|,|\s/)
+          end
+          
+          for key in post_data
+            key = key.downcase.strip
+            # If the key is a delimetered list of values 
+            # (meaning the user didn't use an array but a string with commas)
+            for k_split in key.split(/;|,/)
+              k_split = k_split.downcase.strip #Clean whitespace and junk
+              if !index.has_key?(k_split)
+                index[k_split.to_s] = []
+              end
+              index[k_split.to_s] << post
+            end
+          end
+        end
+        return index
+      end # function index_posts_by
+      
+      #
+      # 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?
+        
+        intersect = first
+        rest.each do |item|
+          return [] if item.nil?
+          intersect = intersect & item
+        end
+        return intersect
+      end #function intersect_arrays
+      
+      #
+      # Filters posts based on a keyed source_posts hash of indexed posts and performs a intersection of 
+      # the two sets. Returns only posts that are common between all collections 
+      #
+      def self.read_config_value_and_filter_posts(config, config_key, posts, source_posts)
+        return nil if posts.nil?
+        return nil if source_posts.nil? # If the source is empty then simply don't do anything
+        return posts if config.nil?
+        return posts if !config.has_key?(config_key)
+        return posts 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]
+        
+        # If we're dealing with a delimitered string instead of an array then let's be forgiving
+        if( config_value.is_a?(String))
+          config_value = config_value.split(/;|,/)
+        end
+          
+        # Now for all filter values for the config key, let's remove all items from the posts that
+        # aren't common for all collections that the user wants to filter on
+        for key in config_value
+          key = key.downcase.strip
+          posts = PaginationIndexer.intersect_arrays(posts, source_posts[key])
+        end
+        
+        # The fully filtered final post list
+        return posts
+      end #function read_config_value_and_filter_posts
+    end #class PaginationIndexer
+
+  end #module PaginateV2
+end #module Jekyll

data/lib/jekyll-paginate-v2/{paginationModel.rb → generator/paginationModel.rb}

@@ -1,13 +1,31 @@
 module Jekyll
-  module PaginateV2
+  module PaginateV2::Generator
 
+    #
+    # The main model for the pagination, handles the orchestration of the pagination and calling all the necessary bits and bobs needed :)
+    #
     class PaginationModel
 
-      def run(default_config, site_pages, site_title, page_create_lambda, logging_lambda, page_remove_lambda, collection_by_name_lambda)
+      @debug = false # is debug output enabled?
+      @logging_lambda = nil # The lambda to use for logging
+      @page_create_lambda = nil # The lambda used to create pages and add them to the site
+      @page_remove_lambda = nil # Lambda to remove a page from the site.pages collection
+      @collection_by_name_lambda = nil # Lambda to get all documents/posts in a particular collection (by name)
+
+      # ctor
+      def initialize(logging_lambda, page_create_lambda, page_remove_lambda, collection_by_name_lambda)
+        @logging_lambda = logging_lambda
+        @page_create_lambda = page_create_lambda
+        @page_remove_lambda = page_remove_lambda
+        @collection_by_name_lambda = collection_by_name_lambda
+      end
+
+
+      def run(default_config, site_pages, site_title)
         # By default if pagination is enabled we attempt to find all index.html pages in the site
         templates = self.discover_paginate_templates(site_pages)
         if( templates.size.to_i <= 0 )
-          logging_lambda.call "Is enabled, but I couldn't find any pagination page. Skipping pagination. "+
+          @logging_lambda.call "Is enabled, but I couldn't find any pagination page. Skipping pagination. "+
           "Pages must have 'paginate: enabled: true' in their front-matter for pagination to work.", "warn"
           return
         end
@@ -17,28 +35,37 @@ module Jekyll
           # All pages that should be paginated need to include the pagination config element
           if template.data['pagination'].is_a?(Hash)
             template_config = default_config.merge(template.data['pagination'])
+
+            # Handling deprecation of configuration values
+            self._fix_deprecated_config_features(template_config)
+
+            @debug = template_config['debug'] # Is debugging enabled on the page level
+
+            self._debug_print_config_info(template_config, template.path)
             
             # Only paginate the template if it is explicitly enabled
             # requiring this makes the logic simpler as I don't need to determine which index pages 
             # were generated automatically and which weren't
             if( template_config['enabled'] )
-              logging_lambda.call "found page: "+template.path
+              if !@debug
+                @logging_lambda.call "found page: "+template.path
+              end
 
               # Request all documents in all collections that the user has requested 
-              all_posts = self.get_docs_in_collections(template_config['collection'], collection_by_name_lambda)
+              all_posts = self.get_docs_in_collections(template_config['collection'])
 
               # Create the necessary indexes for the posts
-              all_categories = self.index_posts_by(all_posts, 'categories')
+              all_categories = PaginationIndexer.index_posts_by(all_posts, 'categories')
               all_categories['posts'] = all_posts; # Populate a category for all posts (this is here for backward compatibility, do not use this as it will be decommissioned 2018-01-01) 
                                                   # (this is a default and must not be used in the category system)
-              all_tags = self.index_posts_by(all_posts, 'tags')
-              all_locales = self.index_posts_by(all_posts, 'locale')
+              all_tags = PaginationIndexer.index_posts_by(all_posts, 'tags')
+              all_locales = PaginationIndexer.index_posts_by(all_posts, 'locale')
 
               # TODO: NOTE!!! This whole request for posts and indexing results could be cached to improve performance, leaving like this for now during testing
 
               # Now construct the pagination data for this template page
               #self.paginate(site, template, template_config, all_posts, all_tags, all_categories, all_locales)
-              self.paginate(template, template_config, site_title, all_posts, all_tags, all_categories, all_locales, page_create_lambda, logging_lambda, page_remove_lambda)
+              self.paginate(template, template_config, site_title, all_posts, all_tags, all_categories, all_locales)
             end
           end
         end #for
@@ -49,7 +76,7 @@ module Jekyll
       # no changes should be made to this function and it should be retired and deleted after 2018-01-01
       # (REMOVE AFTER 2018-01-01)
       #
-      def run_compatability(legacy_config, site_pages, site_title, all_posts, page_create_lambda, logging_lambda)
+      def run_compatability(legacy_config, site_pages, site_title, all_posts)
 
         # Decomissioning error
         if( date = Date.strptime("20180101","%Y%m%d") <= Date.today )
@@ -58,24 +85,24 @@ module Jekyll
 
         # Two month warning or general notification
         if( date = Date.strptime("20171101","%Y%m%d") <= Date.today )
-          logging_lambda.call "Legacy pagination logic will stop working on Jan 1st 2018, update your configs before that time.", "warn"
+          @logging_lambda.call "Legacy pagination logic will stop working on Jan 1st 2018, update your configs before that time.", "warn"
         else
-          logging_lambda.call "Detected legacy jekyll-paginate logic being run. "+
+          @logging_lambda.call "Detected legacy jekyll-paginate logic being run. "+
           "Please update your configs to use the new pagination logic. This compatibility function "+
           "will stop working after Jan 1st 2018 and your site build will throw an error."
         end
 
         if template = CompatibilityUtils.template_page(site_pages, legacy_config['legacy_source'], legacy_config['permalink'])
-          CompatibilityUtils.paginate(legacy_config, all_posts, template, page_create_lambda, logging_lambda)
+          CompatibilityUtils.paginate(legacy_config, all_posts, template, @page_create_lambda)
         else
-          logging_lambda.call "Legacy pagination is enabled, but I couldn't find " +
+          @logging_lambda.call "Legacy pagination is enabled, but I couldn't find " +
           "an index.html page to use as the pagination page. Skipping pagination.", "warn"
         end
       end # function run_compatability (REMOVE AFTER 2018-01-01)
 
       # Returns the combination of all documents in the collections that are specified
       # raw_collection_names can either be a list of collections separated by a ',' or ' ' or a single string
-      def get_docs_in_collections(raw_collection_names, collection_by_name_lambda)
+      def get_docs_in_collections(raw_collection_names)
         if raw_collection_names.is_a?(String)
           collection_names = raw_collection_names.split(/;|,|\s/)
         else
@@ -86,11 +113,58 @@ module Jekyll
         # Now for each of the collections get the docs
         for coll_name in collection_names
           # Request all the documents for the collection in question, and join it with the total collection 
-          docs += collection_by_name_lambda.call(coll_name.downcase.strip)
+          docs += @collection_by_name_lambda.call(coll_name.downcase.strip)
         end
 
         return docs
       end
+
+      def _fix_deprecated_config_features(config)
+        keys_to_delete = []
+
+        # As of v1.5.1 the title_suffix is deprecated and 'title' should be used 
+        # but only if title has not been defined already!
+        if( !config['title_suffix'].nil? )
+          if( config['title'].nil? )
+            config['title'] = ":title" + config['title_suffix'].to_s # Migrate the old key to title
+          end
+          keys_to_delete << "title_suffix" # Always remove the depricated key if found
+        end
+
+        # Delete the depricated keys
+        config.delete_if{ |k,| keys_to_delete.include? k }
+      end
+
+      def _debug_print_config_info(config, page_path)
+        r = 20
+        f = "Pagination: ".rjust(20)
+        # Debug print the config
+        if @debug
+          puts f + "----------------------------"
+          puts f + "Page: "+page_path.to_s
+          puts f + " Active configuration"
+          puts f + "  Enabled: ".ljust(r) + config['enabled'].to_s
+          puts f + "  Items per page: ".ljust(r) + config['per_page'].to_s
+          puts f + "  Permalink: ".ljust(r) + config['permalink'].to_s
+          puts f + "  Title: ".ljust(r) + config['title'].to_s
+          puts f + "  Limit: ".ljust(r) + config['limit'].to_s
+          puts f + "  Sort by: ".ljust(r) + config['sort_field'].to_s
+          puts f + "  Sort reverse: ".ljust(r) + config['sort_reverse'].to_s
+          
+          puts f + " Active Filters"
+          puts f + "  Collection: ".ljust(r) + config['collection'].to_s
+          puts f + "  Category: ".ljust(r) + (config['category'].nil? || config['category'] == "posts" ? "[Not set]" : config['category'].to_s)
+          puts f + "  Tag: ".ljust(r) + (config['tag'].nil? ? "[Not set]" : config['tag'].to_s)
+          puts f + "  Locale: ".ljust(r) + (config['locale'].nil? ? "[Not set]" : config['locale'].to_s)
+
+          if config['legacy'] 
+            puts f + " Legacy Paginate Code Enabled"
+            puts f + "  Legacy Paginate: ".ljust(r) + config['per_page'].to_s
+            puts f + "  Legacy Source: ".ljust(r) + config['legacy_source'].to_s
+            puts f + "  Legacy Path: ".ljust(r) + config['paginate_path'].to_s
+          end
+        end
+      end
       
       #
       # Rolls through all the pages passed in and finds all pages that have pagination enabled on them.
@@ -108,89 +182,6 @@ module Jekyll
         end
         return candidates
       end # function discover_paginate_templates
-     
-      #
-      # Create a hash index for all post based on a key in the post.data table
-      #
-      def index_posts_by(all_posts, index_key)
-        return nil if all_posts.nil?
-        return all_posts if index_key.nil?
-        index = {}
-        for post in all_posts
-          next if post.data.nil?
-          next if !post.data.has_key?(index_key)
-          next if post.data[index_key].nil?
-          next if post.data[index_key].size <= 0
-          next if post.data[index_key].to_s.strip.length == 0
-          
-          # Only tags and categories come as premade arrays, locale does not, so convert any data
-          # elements that are strings into arrays
-          post_data = post.data[index_key]
-          if post_data.is_a?(String)
-            post_data = post_data.split(/;|,|\s/)
-          end
-          
-          for key in post_data
-            key = key.downcase.strip
-            # If the key is a delimetered list of values 
-            # (meaning the user didn't use an array but a string with commas)
-            for k_split in key.split(/;|,/)
-              k_split = k_split.downcase.strip #Clean whitespace and junk
-              if !index.has_key?(k_split)
-                index[k_split.to_s] = []
-              end
-              index[k_split.to_s] << post
-            end
-          end
-        end
-        return index
-      end # function index_posts_by
-      
-      #
-      # Creates an intersection (only returns common elements)
-      # between multiple arrays
-      #
-      def intersect_arrays(first, *rest)
-        return nil if first.nil?
-        return nil if rest.nil?
-        
-        intersect = first
-        rest.each do |item|
-          return [] if item.nil?
-          intersect = intersect & item
-        end
-        return intersect
-      end #function intersect_arrays
-      
-      #
-      # Filters posts based on a keyed source_posts hash of indexed posts and performs a intersection of 
-      # the two sets. Returns only posts that are common between all collections 
-      #
-      def read_config_value_and_filter_posts(config, config_key, posts, source_posts)
-        return nil if posts.nil?
-        return nil if source_posts.nil? # If the source is empty then simply don't do anything
-        return posts if config.nil?
-        return posts if !config.has_key?(config_key)
-        return posts 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]
-        
-        # If we're dealing with a delimitered string instead of an array then let's be forgiving
-        if( config_value.is_a?(String))
-          config_value = config_value.split(/;|,/)
-        end
-          
-        # Now for all filter values for the config key, let's remove all items from the posts that
-        # aren't common for all collections that the user wants to filter on
-        for key in config_value
-          key = key.downcase.strip
-          posts = self.intersect_arrays(posts, source_posts[key])
-        end
-        
-        # The fully filtered final post list
-        return posts
-      end #function read_config_value_and_filter_posts
             
       # Paginates the blog's posts. Renders the index.html file into paginated
       # directories, e.g.: page2/index.html, page3/index.html, etc and adds more
@@ -200,19 +191,19 @@ module Jekyll
       # template - The index.html Page that requires pagination.
       # config - The configuration settings that should be used
       #
-      def paginate(template, config, site_title, all_posts, all_tags, all_categories, all_locales, page_create_lambda, logging_lambda, page_remove_lambda)
+      def paginate(template, config, site_title, all_posts, all_tags, all_categories, all_locales)
         # By default paginate on all posts in the site
         using_posts = all_posts
         
         # Now start filtering out any posts that the user doesn't want included in the pagination
-        using_posts = self.read_config_value_and_filter_posts(config, 'category', using_posts, all_categories)
-        using_posts = self.read_config_value_and_filter_posts(config, 'tag', using_posts, all_tags)
-        using_posts = self.read_config_value_and_filter_posts(config, 'locale', using_posts, all_locales)
+        using_posts = PaginationIndexer.read_config_value_and_filter_posts(config, 'category', using_posts, all_categories)
+        using_posts = PaginationIndexer.read_config_value_and_filter_posts(config, 'tag', using_posts, all_tags)
+        using_posts = PaginationIndexer.read_config_value_and_filter_posts(config, 'locale', using_posts, all_locales)
         
         # Apply sorting to the posts if configured, any field for the post is available for sorting
         if config['sort_field']
           sort_field = config['sort_field'].to_s
-          using_posts.sort!{ |a,b| Utils.sort_values(Utils.sort_get_post_data(a, sort_field), Utils.sort_get_post_data(b, sort_field)) }
+          using_posts.sort!{ |a,b| Utils.sort_values(Utils.sort_get_post_data(a.data, sort_field), Utils.sort_get_post_data(b.data, sort_field)) }
           if config['sort_reverse']
             using_posts.reverse!
           end
@@ -230,18 +221,10 @@ module Jekyll
         # This .pager member is a built in thing in Jekyll and defines the paginator implementation
         # Simpy override to use mine
         (1..total_pages).each do |cur_page_nr|
-          logging_lambda.call "-------------------------------", 'debug'
-          logging_lambda.call "Template.name: "+ template.name, 'debug'
-          logging_lambda.call "Template.url: "+ template.url, 'debug'
-          logging_lambda.call "Template.dir: "+ template.dir, 'debug'
-          logging_lambda.call "Template.basename: "+ template.basename, 'debug'
-          logging_lambda.call "Template.path: "+ template.path, 'debug'
-          logging_lambda.call "Template.ext: "+ template.ext, 'debug'
-
           pager = Paginator.new( config['per_page'], config['permalink'], using_posts, cur_page_nr, total_pages, template.url, template.path )
           
           # External Proc call to create the actual page for us (this is passed in when the pagination is run)
-          newpage = page_create_lambda.call( template.path )
+          newpage = @page_create_lambda.call( template.path )
           newpage.pager = pager
 
           # Force the newly created files to live under the same dir as the template plus the permalink structure
@@ -260,8 +243,8 @@ module Jekyll
             tmp_title = template.data['title']
           end
           # If the user specified a title suffix to be added then let's add that to all the pages except the first
-          if( cur_page_nr > 1 && config.has_key?('title_suffix') )
-            newpage.data['title'] = "#{tmp_title}#{Utils.format_page_number(config['title_suffix'], cur_page_nr)}"
+          if( cur_page_nr > 1 && config.has_key?('title') )
+            newpage.data['title'] = "#{Utils.format_page_title(Utils.format_page_number(config['title'], cur_page_nr), tmp_title)}"
           else
             newpage.data['title'] = tmp_title
           end
@@ -273,15 +256,11 @@ module Jekyll
             newpage.data['autogen'] = "jekyll-paginate-v2"
           end
           
-          logging_lambda.call "newpage.name: "+ newpage.name, 'debug'
-          logging_lambda.call "newpage.url: "+ newpage.url, 'debug'
-          logging_lambda.call "newpage.dir: "+ newpage.dir, 'debug'  
-          
           # Only request that the template page be removed from the output once
           # We actually create a dummy page for this actual page in the Jekyll output 
           # so we don't need the original page anymore
           if cur_page_nr == 1
-            page_remove_lambda.call( template )
+            @page_remove_lambda.call( template )
           end
         end
       end # function paginate

data/lib/jekyll-paginate-v2/{paginationPage.rb → generator/paginationPage.rb}

@@ -1,5 +1,5 @@
 module Jekyll
-  module PaginateV2
+  module PaginateV2::Generator
 
     #
     # This page handles the creation of the fake pagination pages based on the original page configuration

data/lib/jekyll-paginate-v2/{paginator.rb → generator/paginator.rb}

@@ -1,5 +1,5 @@
 module Jekyll
-  module PaginateV2
+  module PaginateV2::Generator
     
     #
     # Handles the preparation of all the posts based on the current page index

data/lib/jekyll-paginate-v2/{utils.rb → generator/utils.rb}

@@ -1,5 +1,5 @@
 module Jekyll 
-  module PaginateV2
+  module PaginateV2::Generator
 
     #
     # Static utility functions that are used in the code and 
@@ -36,7 +36,8 @@ module Jekyll
         # If the template url is not just root "/" then pre-pend the template_url path to it
         template_dir = File.dirname(template_path)
         if( template_dir != "" && template_dir != "/" )
-          permalink_format = File.join(template_url, permalink_format)
+          template_url_noext = File.join(File.dirname(template_url), File.basename(template_url, '.*'))
+          permalink_format = File.join(template_url_noext, permalink_format)
         end
 
         Utils.ensure_leading_slash(permalink_format)
@@ -47,6 +48,12 @@ module Jekyll
       def self.format_page_number(toFormat, cur_page_nr)
         return toFormat.sub(':num', cur_page_nr.to_s)
       end #function format_page_number
+
+      # Static: returns a fully formatted string with the :title variable replaced
+      #
+      def self.format_page_title(toFormat, title)
+        return toFormat.sub(':title', title.to_s)
+      end #function format_page_title
       
       # Static: Return a String version of the input which has a leading slash.
       #         If the input already has a forward slash in position zero, it will be
@@ -84,11 +91,11 @@ module Jekyll
       # Retrieves the given sort field from the given post
       # the sort_field variable can be a hierarchical value on the form "parent_field:child_field" repeated as many times as needed
       # only the leaf child_field will be retrieved  
-      def self.sort_get_post_data(post, sort_field)
+      def self.sort_get_post_data(post_data, sort_field)
         
         # Begin by splitting up the sort_field by (;,:.)
         sort_split = sort_field.split(":")
-        sort_value = post.data
+        sort_value = post_data
 
         for r_key in sort_split
           key = r_key.downcase.strip # Remove any erronious whitespace and convert to lower case