jekyll-paginate-v2 1.5.2 → 1.6.0

data/jekyll-paginate-v2.gemspec

@@ -7,6 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "jekyll-paginate-v2"
   spec.version       = Jekyll::PaginateV2::VERSION
   spec.platform      = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 2.0.0'  # Same as Jekyll
   spec.date          = DateTime.now.strftime('%Y-%m-%d')
   spec.authors       = ["Sverrir Sigmundarson"]
   spec.email         = ["jekyll@sverrirs.com"]
@@ -14,16 +15,18 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.summary       = %q{Pagination Generator for Jekyll 3}
-  spec.description   = %q{An enhanced zero-configuration in-place replacement for the now decomissioned built-in jekyll-paginate gem. This pagination gem offers full backwards compatability as well as a slew of new frequently requested features with minimal additional site and page configuration.}
+  spec.description   = %q{An enhanced zero-configuration in-place replacement for the now decomissioned built-in jekyll-paginate gem. This pagination gem offers full backwards compatability as well as a slew of new frequently requested features with minimal additional site and page configuration. Optional features include auto-generation of paginated collection, tag and category pages.}
   
-  #spec.files         = `git ls-files -z`.split("\x0")
-  spec.files          = Dir['CODE_OF_CONDUCT.md', 'README.md', 'LICENSE', 'Rakefile', '*.gemspec', 'Gemfile', 'lib/**/*', 'spec/**/*']
-  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.files          = Dir['CODE_OF_CONDUCT.md', 'README*.md', 'LICENSE', 'Rakefile', '*.gemspec', 'Gemfile', 'lib/**/*', 'spec/**/*']
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "jekyll", ">= 3.0"
+  # Gem requires Jekyll to work
+  # ~> is the pessimistic operator and is equivalent to '>= 3.0', '< 4.0'
+  spec.add_runtime_dependency "jekyll", "~> 3.0"
+
+  # Development requires more
   spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest", '~> 5.4', '>= 5.4.3'
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency "minitest", '~> 5.4'
 end

data/lib/jekyll-paginate-v2.rb

@@ -20,7 +20,13 @@ require "jekyll-paginate-v2/generator/paginationPage"
 require "jekyll-paginate-v2/generator/paginationModel"
 require "jekyll-paginate-v2/generator/paginationGenerator"
 # Files needed for the auto category and tag pages
-
+require "jekyll-paginate-v2/autopages/utils"
+require "jekyll-paginate-v2/autopages/defaults"
+require "jekyll-paginate-v2/autopages/autoPages"
+require "jekyll-paginate-v2/autopages/pages/baseAutoPage"
+require "jekyll-paginate-v2/autopages/pages/categoryAutoPage"
+require "jekyll-paginate-v2/autopages/pages/collectionAutoPage"
+require "jekyll-paginate-v2/autopages/pages/tagAutoPage"
 
 module Jekyll 
   module PaginateV2

data/lib/jekyll-paginate-v2/autopages/autoPages.rb

@@ -0,0 +1,77 @@
+module Jekyll
+  module PaginateV2::AutoPages
+
+    #
+    # When the site has been read then go a head an generate the necessary extra pages
+    # This code is adapted from Stephen Crosby's code https://github.com/stevecrozz
+    Jekyll::Hooks.register :site, :post_read do |site|
+
+      # Get the configuration for the auto pages
+      autopage_config = Jekyll::Utils.deep_merge_hashes(DEFAULT, site.config['autopages'] || {})
+      pagination_config = Jekyll::Utils.deep_merge_hashes(Jekyll::PaginateV2::Generator::DEFAULT, site.config['pagination'] || {})
+
+      # If disabled then don't do anything
+      if !autopage_config['enabled'] || autopage_config['enabled'].nil?
+        Jekyll.logger.info "AutoPages:","Disabled/Not configured in site.config."
+        next ## Break the loop, could be an issue if the hook is called again though??
+      end
+
+      # TODO: Should I detect here and disable if we're running the legacy paginate code???!
+
+      # Simply gather all documents across all pages/posts/collections that we have
+      # we could be generating quite a few empty pages but the logic is just vastly simpler than trying to 
+      # figure out what tag/category belong to which collection.
+      posts_to_use = Utils.collect_all_docs(site.collections)
+
+      ###############################################
+      # Generate the Tag pages if enabled
+      createtagpage_lambda = lambda do | autopage_tag_config, pagination_config, layout_name, tag |
+        site.pages << TagAutoPage.new(site, site.dest, autopage_tag_config, pagination_config, layout_name, tag)
+      end
+      autopage_create(autopage_config, pagination_config, posts_to_use, 'tags', 'tags', createtagpage_lambda) # Call the actual function
+      
+
+      ###############################################
+      # Generate the category pages if enabled
+      createcatpage_lambda = lambda do | autopage_cat_config, pagination_config, layout_name, category |
+        site.pages << CategoryAutoPage.new(site, site.dest, autopage_cat_config, pagination_config, layout_name, category)
+      end
+      autopage_create(autopage_config, pagination_config,posts_to_use, 'categories', 'categories', createcatpage_lambda) # Call the actual function
+      
+      ###############################################
+      # Generate the Collection pages if enabled
+      createcolpage_lambda = lambda do | autopage_col_config, pagination_config, layout_name, coll_name |
+        site.pages << CollectionAutoPage.new(site, site.dest, autopage_col_config, pagination_config, layout_name, coll_name)
+      end
+      autopage_create(autopage_config, pagination_config,posts_to_use, 'collections', '__coll', createcolpage_lambda) # Call the actual function
+    
+    end # Jekyll::Hooks
+
+
+    # STATIC: this function actually performs the steps to generate the autopages. It uses a lambda function to delegate the creation of the individual
+    #         page types to the calling code (this way all features can reuse the logic).
+    #
+    def self.autopage_create(autopage_config, pagination_config, posts_to_use, configkey_name, indexkey_name, createpage_lambda )
+       if !autopage_config[configkey_name].nil?
+        ap_sub_config = autopage_config[configkey_name]
+        if ap_sub_config ['enabled']
+          Jekyll.logger.info "AutoPages:","Generating #{configkey_name} pages"
+
+          # Roll through all documents in the posts collection and extract the tags
+          index_keys = Utils.index_posts_by(posts_to_use, indexkey_name).keys # Cannot use just the posts here, must use all things.. posts, collections...
+
+          index_keys.each do |index_key|
+            # Iterate over each layout specified in the config
+            ap_sub_config ['layouts'].each do | layout_name |
+              # Use site.dest here as these pages are never created in the actual source but only inside the _site folder
+              createpage_lambda.call(ap_sub_config, pagination_config, layout_name, index_key)
+            end
+          end
+        else
+          Jekyll.logger.info "AutoPages:","#{configkey_name} pages are disabled/not configured in site.config."
+        end
+      end
+    end
+
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/defaults.rb

@@ -1,26 +1,29 @@
 module Jekyll
   module PaginateV2::AutoPages
 
-    # Construct an extended version of the pagination config for the tag pages
-    tagDefaults = Jekyll::PaginateV2::Generator::DEFAULT.merge({
-      'layout'        => 'autopage_tags.html',
-      'title'         => 'Posts tagged with :tag',
-      'permalink'     => '/tags/:tag'
-    })
-
-    # Extend the pagination config for the categories as well
-    catDefaults = Jekyll::PaginateV2::Generator::DEFAULT.merge({
-      'layout'        => 'autopage_category.html',
-      'title'         => 'Posts in category :cat',
-      'permalink'     => '/category/:cat'
-    })
-
     # The default configuration for the AutoPages
     DEFAULT = {
-      'enabled' => false,
-      'tags'    => tagDefaults,
-      'category'=> catDefaults 
+      'enabled'     => false,
+      'tags'        => {
+        'layouts'       => ['autopage_tags.html'],
+        'title'         => 'Posts tagged with :tag`',
+        'permalink'     => '/tag/:tag',
+        'enabled'       => true
+
+      },
+      'categories'  => {
+        'layouts'       => ['autopage_category.html'],
+        'title'         => 'Posts in category :cat',
+        'permalink'     => '/category/:cat',
+        'enabled'       => true
+      },
+      'collections' => {
+        'layouts'       => ['autopage_collection.html'],
+        'title'         => 'Posts in collection :coll',
+        'permalink'     => '/collection/:coll',
+        'enabled'       => true
+      } 
     }
 
-  end # module PaginateV2
+  end # module PaginateV2::AutoPages
 end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/pages/baseAutoPage.rb

@@ -0,0 +1,60 @@
+module Jekyll
+  module PaginateV2::AutoPages
+
+    class BaseAutoPage < Jekyll::Page
+      def initialize(site, base, autopage_config, pagination_config, layout_name, set_autopage_data_lambda, get_autopage_permalink_lambda, get_autopage_title_lambda)
+        @site = site
+        @base = base
+        @name = 'index.html'
+                
+        layout_dir = '_layouts'
+
+        # Path is only used by the convertible module and accessed below when calling read_yaml
+        # Handling themes stored in a gem
+        @path = if site.in_theme_dir(site.source) == site.source # we're in a theme
+                  site.in_theme_dir(site.source, layout_dir, layout_name)
+                else
+                  site.in_source_dir(site.source, layout_dir, layout_name)
+                end
+        
+        self.process(@name) # Creates the base name and extension
+        self.read_yaml(File.join(site.source, layout_dir), layout_name)
+
+        # Merge the config with any config that might already be defined in the layout
+        pagination_layout_config = Jekyll::Utils.deep_merge_hashes( pagination_config, self.data['pagination'] || {} )
+
+        # Read any possible autopage overrides in the layout page
+        autopage_layout_config = Jekyll::Utils.deep_merge_hashes( autopage_config, self.data['autopages'] || {} )
+        
+        # Now set the page specific pagination data
+        set_autopage_data_lambda.call(pagination_layout_config)
+
+        # Get permalink structure
+        permalink_formatted = get_autopage_permalink_lambda.call(autopage_layout_config['permalink'])
+
+        # Construct the title
+        page_title = autopage_layout_config['title']
+               
+        # NOTE: Should we set this before calling read_yaml as that function validates the permalink structure 
+        self.data['permalink'] = permalink_formatted
+        @url = File.join(permalink_formatted, @name)
+        @dir = permalink_formatted
+
+        self.data['layout'] = File.basename(layout_name, File.extname(layout_name))
+        self.data['title'] = get_autopage_title_lambda.call( page_title )
+        self.data['pagination']  = pagination_layout_config # Store the pagination configuration
+
+        # Add the auto page flag in there to be able to detect the page (necessary when figuring out where to load it from)
+        # TODO: Need to re-think this variable!!!
+        self.data['autopage'] = {"layout_path" => File.join( layout_dir, layout_name ) }
+
+        data.default_proc = proc do |_, key|
+          site.frontmatter_defaults.find(File.join(layout_dir, layout_name), type, key)
+        end
+
+        # Trigger a page event
+        #Jekyll::Hooks.trigger :pages, :post_init, self
+      end #function initialize
+    end #class BaseAutoPage
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/pages/categoryAutoPage.rb

@@ -0,0 +1,28 @@
+module Jekyll
+  module PaginateV2::AutoPages
+
+    class CategoryAutoPage < BaseAutoPage
+      def initialize(site, base, autopage_config, pagination_config, layout_name, category)
+
+        # Construc the lambda function to set the config values
+        # this function received the pagination config hash and manipulates it
+        set_autopage_data_lambda = lambda do | in_config |
+          in_config['category'] = category
+        end
+
+        get_autopage_permalink_lambda = lambda do |permalink_pattern|
+          return Utils.format_cat_macro(permalink_pattern, category)
+        end
+
+        get_autopage_title_lambda = lambda do |title_pattern|
+          return Utils.format_cat_macro(title_pattern, category)
+        end
+                
+        # Call the super constuctor with our custom lambda
+        super(site, base, autopage_config, pagination_config, layout_name, set_autopage_data_lambda, get_autopage_permalink_lambda, get_autopage_title_lambda)
+        
+      end #function initialize
+
+    end #class CategoryAutoPage
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/pages/collectionAutoPage.rb

@@ -0,0 +1,28 @@
+module Jekyll
+  module PaginateV2::AutoPages
+
+    class CollectionAutoPage < BaseAutoPage
+      def initialize(site, base, autopage_config, pagination_config, layout_name, collection)
+
+        # Construc the lambda function to set the config values
+        # this function received the pagination config hash and manipulates it
+        set_autopage_data_lambda = lambda do | in_config |
+          in_config['collection'] = collection
+        end
+
+        get_autopage_permalink_lambda = lambda do |permalink_pattern|
+          return Utils.format_coll_macro(permalink_pattern, collection)
+        end
+
+        get_autopage_title_lambda = lambda do |title_pattern|
+          return Utils.format_coll_macro(title_pattern, collection)
+        end
+                
+        # Call the super constuctor with our custom lambda
+        super(site, base, autopage_config, pagination_config, layout_name, set_autopage_data_lambda, get_autopage_permalink_lambda, get_autopage_title_lambda)
+        
+      end #function initialize
+
+    end #class CollectionAutoPage
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/pages/tagAutoPage.rb

@@ -0,0 +1,28 @@
+module Jekyll
+  module PaginateV2::AutoPages
+
+    class TagAutoPage < BaseAutoPage
+      def initialize(site, base, autopage_config, pagination_config, layout_name, tag)
+
+        # Construc the lambda function to set the config values, 
+        # this function received the pagination config hash and manipulates it
+        set_autopage_data_lambda = lambda do | config |
+          config['tag'] = tag
+        end
+
+        get_autopage_permalink_lambda = lambda do |permalink_pattern|
+          return Utils.format_tag_macro(permalink_pattern, tag)
+        end
+
+        get_autopage_title_lambda = lambda do |title_pattern|
+          return Utils.format_tag_macro(title_pattern, tag)
+        end
+                
+        # Call the super constuctor with our custom lambda
+        super(site, base, autopage_config, pagination_config, layout_name, set_autopage_data_lambda, get_autopage_permalink_lambda, get_autopage_title_lambda)
+        
+      end #function initialize
+
+    end #class TagAutoPage
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/autopages/utils.rb

@@ -6,14 +6,66 @@ module Jekyll
       # Static: returns a fully formatted string with the tag macro (:tag) replaced
       #
       def self.format_tag_macro(toFormat, tag)
-        return toFormat.sub(':tag', Jekyll::Utils.slugify(tag.to_s)
+        return toFormat.sub(':tag', Jekyll::Utils.slugify(tag.to_s))
       end #function format_tag_macro
 
       # Static: returns a fully formatted string with the category macro (:cat) replaced
       #
       def self.format_cat_macro(toFormat, category)
         return toFormat.sub(':cat', Jekyll::Utils.slugify(category.to_s))
-      end #function format_tag_macro
+      end #function format_cat_macro
+
+      # Static: returns a fully formatted string with the collection macro (:coll) replaced
+      #
+      def self.format_coll_macro(toFormat, collection)
+        return toFormat.sub(':coll', Jekyll::Utils.slugify(collection.to_s))
+      end #function format_coll_macro
+
+      # Static: returns all documents from all collections defined in the hash of collections passed in
+      # excludes all pagination pages though
+      def self.collect_all_docs(site_collections)
+        coll = []
+        for coll_name, coll_data in site_collections
+          if !coll_data.nil? 
+            coll += coll_data.docs.select { |doc| !doc.data.has_key?('pagination') }.each{ |doc| doc.data['__coll'] = coll_name } # Exclude all pagination pages and then for every page store it's collection name
+          end
+        end
+        return coll
+      end
+
+      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
 
     end # class Utils
 

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

@@ -1,6 +1,35 @@
 module Jekyll 
   module PaginateV2::Generator
 
+    class CompatibilityPaginationPage < Page
+      def initialize(site, base, dir, template_path)
+        @site = site
+        @base = base
+        @dir = dir
+        @template = template_path
+        @name = 'index.html'
+
+        templ_dir = File.dirname(template_path)
+        templ_file = File.basename(template_path)
+
+        # Path is only used by the convertible module and accessed below when calling read_yaml
+        # in our case we have the path point to the original template instead of our faux new pagination page
+        @path = if site.in_theme_dir(base) == base # we're in a theme
+                  site.in_theme_dir(base, templ_dir, templ_file)
+                else
+                  site.in_source_dir(base, templ_dir, templ_file)
+                end
+        
+        self.process(@name)
+        self.read_yaml(templ_dir, templ_file)
+
+        data.default_proc = proc do |_, key|
+          site.frontmatter_defaults.find(File.join(templ_dir, templ_file), type, key)
+        end
+
+      end
+    end # class CompatibilityPaginationPage
+
     #
     # Static utility functions that provide backwards compatibility with the old 
     # jekyll-paginate gem that this new version superseeds (this code is here to ensure)
@@ -50,21 +79,43 @@ module Jekyll
       # directories, e.g.: page2/index.html, page3/index.html, etc and adds more
       # site-wide data.
       #
-      def self.paginate(legacy_config, all_posts, page, page_create_lambda )
+      def self.paginate(legacy_config, all_posts, page, page_add_lambda )
         pages = Utils.calculate_number_of_pages(all_posts, legacy_config['per_page'].to_i)
         (1..pages).each do |num_page|
-          pager = Paginator.new( legacy_config['per_page'], legacy_config['permalink'], all_posts, num_page, pages, page.url, page.path )
+          pager = Paginator.new( legacy_config['per_page'], page.url, legacy_config['permalink'], all_posts, num_page, pages )
           if num_page > 1
-            newpage = page_create_lambda.call( page.path )
+            template_full_path = File.join(page.site.source, page.path)
+            template_dir = File.dirname(page.path)
+            newpage = CompatibilityPaginationPage.new(page.site, page.site.source, template_dir, template_full_path)
             newpage.pager = pager
-            newpage.dir = Utils.paginate_path(page.url, page.path, num_page, legacy_config['permalink'])
+            newpage.dir = CompatibilityUtils.paginate_path(page.url, num_page, legacy_config['permalink'])
             newpage.data['autogen'] = "jekyll-paginate-v2" # Signals that this page is automatically generated by the pagination logic
+            page_add_lambda.call(newpage)
           else
             page.pager = pager
           end
         end
       end
 
+      # Static: Return the pagination path of the page
+      #
+      # site     - the Jekyll::Site object
+      # cur_page_nr - the pagination page number
+      # config - the current configuration in use
+      #
+      # Returns the pagination path as a string
+      def self.paginate_path(template_url, cur_page_nr, permalink_format)
+        return nil if cur_page_nr.nil?
+        return template_url if cur_page_nr <= 1
+        if permalink_format.include?(":num")
+          permalink_format = Utils.format_page_number(permalink_format, cur_page_nr)
+        else
+          raise ArgumentError.new("Invalid pagination path: '#{permalink_format}'. It must include ':num'.")
+        end
+
+        Utils.ensure_leading_slash(permalink_format)
+      end #function paginate_path
+
     end # class CompatibilityUtils
   end # module PaginateV2
 end # module Jekyll