jekyll-paginate-v2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd4827a1c9dd80de07ba232d75d61c573b52eeaf
+  data.tar.gz: a6238314308d5a386f8fab3f2b28f730b51ab8a7
+SHA512:
+  metadata.gz: 917b6eadca4c14048091ee608c8a284ba17ed3d5a8430c8723828b5cfda7918a64658dbbf7fccd53783ea25253a6e3edaf6432bce4c878c34d6a81884e151466
+  data.tar.gz: 72686ab7df0df3a8d2686f4c8141645df09c82248c547215f1fc2a5bbe4f4db40e19f2a672d8869abfac8a6408f36d0ce16aa983cc35736b35c50596ec93bc36

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/dest
+tmp

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jekyll-paginate-v2.gemspec
+gemspec
+
+if ENV["JEKYLL_VERSION"]
+  gem "jekyll", "~> #{ENV["JEKYLL_VERSION"]}"
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sverrir Sigmundarson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,248 @@
+# Jekyll::Paginate V2
+
+Pagination plugin built specially for Jekyll 3 and newer.
+
+Enhanced replacement for the previously built-in [jekyll-paginate gem](https://github.com/jekyll/jekyll-paginate).
+
+The code was based on the original design of [jekyll-paginate](https://github.com/jekyll/jekyll-paginate) and features were mostly drawn from discussions from the issues pages (especially https://github.com/jekyll/jekyll-paginate/issues/27) and some from the excellent [Octopress::Paginate code](https://github.com/octopress/paginate). 
+
+Thanks everybody :heart:
+
+## Features
+
+In addition to all the features offered by the older [jekyll-paginate gem](https://github.com/jekyll/jekyll-paginate) this new pagination plugin features include
+
+1. Works with any type of file ending (HTML, Markdown, etc) as long as the file has front-matter and the minimum page level pagination meta (see [page-configuration](#page-configuration)).
+2. Paginated files can have any file name (not just index.html).
+3. Supports category, tag and locale filtering.
+4. Supports any combination of category, tag and locale filtering (e.g. _all posts in the 'ruby' category written for 'en\_US'_ or _all posts in 'car' and 'cycle' category tagged with 'cool' written for 'fr\_FR'_)
+5. Sorting of posts by any field. Decending or Ascending.
+6. Optional limits of number of pagenated pages (e.g. _only produce 15 pages_)
+7. Fully customizable permalink format. E.g `/page:num/` or `/page/:num/` or `/:num/` or really anything you want.
+8. Optional title suffix for paginated pages (e.g. _Index - Page 2_)
+
+All this while being fully backwards compatible with the old [jekyll-paginate](https://github.com/jekyll/jekyll-paginate) gem (requires minimal additional front-matter, see [page-configuration](#page-configuration)).
+
+## Installation
+
+Currently this plugin is in develpment mode and is not yet distributed as a gem (mostly because I don't know how).
+
+To install, simply copy the `lib\jekyll-paginate-v2.rb` file into the `_plugins` folder under your Jekyll site root. 
+> If the _plugins folder does not exist simply create it.
+
+Then add the necessary [Site YML](#site-configuration) and [Page](#page-configuration) configuration elements.
+
+Run `jekyll serve` and you should see the pagination plugin debug messages printed during site generation:
+
+``` bash
+  Generating...
+    Pagination: found template: pictures/bestof.md
+    Pagination: found template: puffins/list.html
+    Pagination: found template: index.html
+```
+
+## Current state
+
+Currently this code is in dire need of feedback, code review and testing.
+
+I also would welcome guidance on how to write automated tests for this code so that I can publish it as a Gem.
+
+Come to think of it, I currently have no idea on how to publish a Gem... :/
+
+> Don't worry too much about the current structure, this is just the first iteration.
+> The code is currently a single file `jekyll-paginate-v2.rb` only because it makes it faster to develop and debug. As soon as I and hopefully other people test and green-light the logic I intend to break this code into separate files and distribute as a gem.  
+
+## Contributing
+
+1. Fork it ( https://github.com/sverrirs/jekyll-paginate-v2/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Site configuration
+
+The plugin can be configured in the site's `_config.yml` file by including the `pagination` configuration element
+
+``` yml
+############################################################
+# Site configuration for the Jekyll 3 Pagination Plugin
+# The values here represent the defaults if nothing is set
+pagination:
+  
+  # Site-wide kill switch, disabled here it doesn't run at all 
+  enabled: true
+
+  # How many objects per paginated page, used to be `paginate` (default: 0, means all)
+  per_page: 10
+
+  # The permalink structure for the paginated pages (this can be any level deep)
+  permalink: '/page/:num/'
+
+  # Optional additional suffix for the title of the paginated pages (the prefix is inherited from the template page)
+  title_suffix: ' - page :num'
+
+  # Limit how many pagenated pages to create (default: 0, means all)
+  limit: 0
+  
+  # Optional, defines the field that the posts should be sorted on (omit to default to 'date')
+  sort_field: 'date'
+
+  # Optional, sorts the posts in reverse order (omit to default decending or sort_reverse: true)
+  sort_reverse: true
+
+  # The default category to use, just leave this as 'posts' to get a backwards-compatible behavior (all posts)
+  category: 'posts'
+
+  # Optional, the default tag to use, omit to disable
+  tag: 'cool'
+
+  # Optional, the default locale to use, omit to disable (depends on a field 'locale' to be specified in the posts, 
+  # in reality this can be any value, suggested are the Microsoft locale-codes (e.g. en_US, en_GB) or simply the ISO-639 language code )
+  locale: 'en_US' 
+
+############################################################
+```
+
+## Page configuration
+
+To enable pagination on a page (i.e. make that page a template for pagination) then simply include the minimal pagination configuration in the page front-matter:
+
+``` yml
+pagination: 
+  enabled: true
+```
+
+Then you can use the normal `paginator.posts` logic to iterate through the posts.
+
+``` html
+{% for post in paginator.posts %}
+  <h1>{{ post.title }}</h1>
+{% endfor %}
+```
+
+And to display pagination links, simply
+
+``` html
+{% if paginator.total_pages > 1 %}
+<ul class="pager">
+    {% if paginator.previous_page %}
+    <li class="previous">
+        <a href="{{ paginator.previous_page_path | prepend: site.baseurl | replace: '//', '/' }}">Newer Posts</a>
+    </li>
+    {% endif %}
+    {% if paginator.next_page %}
+    <li class="next">
+        <a href="{{ paginator.next_page_path | prepend: site.baseurl | replace: '//', '/' }}">Older Posts</a>
+    </li>
+    {% endif %}
+</ul>
+{% endif %}
+```
+
+The code is fully backwards compatible and you will have access to all the normal paginator variables defined in the [official jekyll documentation](https://jekyllrb.com/docs/pagination/#liquid-attributes-available). 
+
+Neat!
+
+## Paginate categories, tags, locales
+
+Enabling pagination for specific categories, tags or locales is as simple as adding values to the pagination template front-matter and corresponding values in the posts.
+
+### Filtering categories
+
+Filter single category 'software'
+
+``` yml
+pagination: 
+  enabled: true
+  category: software
+```
+
+Filter multiple categories (lists only posts belonging to all categories)
+
+``` yml
+pagination: 
+  enabled: true
+  category: software, ruby
+```
+
+> To define categories you can either specify them in the front-matter or through the [directory structure](http://jekyllrb.com/docs/variables/#page-variables) of your jekyll site (Categories are derived from the directory structure above the \_posts directory). You can actually use both approaches to assign your pages to multiple categories.
+
+### Filtering tags
+
+Filter on a single tag
+
+``` yml
+pagination: 
+  enabled: true
+  tag: cool
+```
+
+Filter on multiple tags
+
+``` yml
+pagination: 
+  enabled: true
+  tag: cool, life
+```
+
+### Filtering locales
+
+In the case your site offers multiple languages you can include a `locale` item in your post front matter. The paginator can then use this value to filter on
+
+The category page front-matter would look like this
+
+``` yml
+pagination: 
+  enabled: true
+  locale: en_US
+```
+
+Then for the relevant posts, include the `locale` variable in their front-matter
+
+``` yml 
+locale: en_US
+```
+
+## Paginate on combination of filters
+
+Including only posts from categories 'ruby' and 'software' written in English
+
+``` yml
+pagination: 
+  enabled: true
+  category: software, ruby
+  locale: en_US, en_GB, en_WW
+```
+
+Only showing posts tagged with 'cool' and in category 'cars'
+
+``` yml
+pagination: 
+  enabled: true
+  category: cars
+  tag: cool
+```
+
+... and so on and so on
+
+## Configuration overrides
+
+All of the configuration elements from the `_config.yml` file can be overwritten in the pagination template pages. E.g. if you want one category page to have different permalink structure simply override the item like so
+
+``` yml
+pagination: 
+  enabled: true
+  category: cars
+  permalink: '/cars/:num/'
+```
+
+Overriding sorting to sort by the post title in ascending order for another paginated template could be done like so
+
+``` yml
+pagination: 
+  enabled: true
+  category: ruby
+  sort_field: 'title'
+  sort_reverse: false
+```

data/jekyll-paginate-v2.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jekyll-paginate-v2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jekyll-paginate-v2"
+  spec.version       = Jekyll::PaginateV2::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.date          = '2016-11-18'
+  spec.authors       = ["Sverrir Sigmundarson"]
+  spec.email         = ["jekyll@sverrirs.com"]
+  spec.homepage      = "https://github.com/sverrirs/jekyll-paginate-v2"
+  spec.license       = "MIT"
+
+  spec.summary       = %q{Pagination Generator for Jekyll 3}
+  spec.description   = %q{An enhanced in-place replacement for the previously built-in jekyll-paginate gem offering full backwards compatability as well as a slew of new frequently requested features}
+  
+  spec.files         = `git ls-files -z`.split("\x0")
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  #spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "jekyll", ">= 3.0"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/jekyll-paginate-v2.rb

@@ -0,0 +1,21 @@
+# Jekyll::Paginate V2 is a gem built for Jekyll 3 that generates pagiatation for posts, categories and tags.
+# 
+# It is based on https://github.com/jekyll/jekyll-paginate, the original Jekyll paginator
+# which was decommissioned in Jekyll 3 release onwards. This code is currently not officially
+# supported on Jekyll versions < 3.0 (although it might work)
+#
+# Author: Sverrir Sigmundarson
+# Site: https://github.com/sverrirs/jekyll-paginate-v2
+# Distributed Under The MIT License (MIT) as described in the LICENSE file
+#   - https://opensource.org/licenses/MIT
+
+require "jekyll-paginate-v2/version"
+require "jekyll-paginate-v2/defaults"
+require "jekyll-paginate-v2/utils"
+require "jekyll-paginate-v2/paginator"
+require "jekyll-paginate-v2/pagination"
+
+module Jekyll 
+  module PaginateV2
+  end # module PaginateV2
+end # module Jekyll

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

@@ -0,0 +1,18 @@
+module Jekyll
+  module PaginateV2
+
+    # The default configuration for the Paginator
+    DEFAULT = {
+      'enabled'      => false,
+      'collection'   => 'posts',
+      'per_page'     => 10,
+      'permalink'    => '/page:num/', # Supports :num as customizable elements
+      'title_suffix' => ' - page :num', # Supports :num as customizable elements
+      'page_num'     => 1,
+      'sort_reverse' => false,
+      'sort_field'   => 'date',
+      'limit'        => 0 # Limit how many content objects to paginate (default: 0, means all)
+    }
+
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/pagination.rb

@@ -0,0 +1,252 @@
+module Jekyll
+  module PaginateV2
+
+    class PaginationV2 < Generator
+      # This generator is safe from arbitrary code execution.
+      safe true
+
+      # 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 folate configuration from the site yml file
+        default_config = DEFAULT.merge(site.config['pagination'] || {})
+        
+        # If disabled then simply quit
+        if !default_config['enabled']
+          Jekyll.logger.info "Pagination:","disabled in site.config."
+          return
+        end
+        
+        Jekyll.logger.debug "Pagination:","Starting"
+        
+        # By default if pagination is enabled we attempt to find all index.html pages in the site
+        templates = self.discover_paginate_templates(site)
+        if( templates.size.to_i <= 0 )
+          Jekyll.logger.warn "Pagination:","is enabled, but I couldn't find " +
+          "any index.html page to use as the pagination template. Skipping pagination."
+          return
+        end
+
+        # Get all posts that will be generated (excluding hidden posts such as drafts)
+        all_posts = site.site_payload['site']['posts'].reject { |post| post['hidden'] }
+
+        # Create the necessary indexes for the posts
+        all_categories = self.index_posts_by(all_posts, 'categories')
+        all_categories['posts'] = all_posts; # Popuplate a category for all posts 
+                                             # (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')
+        
+        # Now for each template page generate the paginator for it
+        for template in templates
+          
+          # 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'])
+            
+            # 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'] )
+              Jekyll.logger.info "Pagination:","found template: "+template.path
+              # Now construct the pagination data for this template page
+              self.paginate(site, template, template_config, all_posts, all_tags, all_categories, all_locales)
+            end
+          end
+        end #for
+        
+      end # function generate
+      
+      #
+      # Rolls through the entire site and finds all index.html pages available
+      #
+      # site - The Site.
+      #
+      def discover_paginate_templates(site)
+        candidates = []
+        site.pages.select do |page|
+          # If the page has the enabled config set, supports any type of file name html or md
+          if page.data['pagination'].is_a?(Hash) && page.data['pagination']['enabled']
+            candidates << page
+          end
+        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
+      
+      #
+      # Sorting routine used for ordering posts by custom fields.
+      # Handles Strings separately as we want a case-insenstive sorting
+      #
+      def _sort_posts(a, b)
+        if a.is_a?(String)
+          return a.downcase <=> b.downcase
+        end
+        
+        # By default use the built in sorting for the data type
+        return a <=> b
+      end
+      
+      # 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
+      # site-wide data.
+      #
+      # site - The Site.
+      # template - The index.html Page that requires pagination.
+      # config - The configuration settings that should be used
+      #
+      def paginate(site, template, config, 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)
+        
+        # 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| self._sort_posts(a.data[sort_field], b.data[sort_field]) }
+          
+          if config['sort_reverse']
+            using_posts.reverse!
+          end
+        end
+               
+        # Calculate the max number of pagination-pages based on the configured per page value
+        total_pages = self.calculate_number_of_pages(using_posts, config['per_page'])
+        
+        # If a upper limit is set on the number of total pagination pages then impose that now
+        if config['limit'] && config['limit'].to_i > 0 && config['limit'].to_i < total_pages
+          total_pages = config['limit'].to_i
+        end
+        
+        # Now for each pagination page create it and configure the ranges for the collection
+        # 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|
+          pager = PaginatorV2.new( config, using_posts, cur_page_nr, total_pages, template )
+          if( cur_page_nr > 1)
+            newpage = Page.new( site, site.source, template.dir, template.name)
+            newpage.pager = pager
+            newpage.dir = Utils.paginate_path(template, cur_page_nr, config)
+            if( config.has_key?('title_suffix'))
+              if( !template.data['title'] )
+                tmp_title = site.config['title']
+              else
+                tmp_title = template.data['title']
+              end
+               
+              newpage.data['title'] = "#{tmp_title}#{Utils.format_page_number(config['title_suffix'], cur_page_nr)}"
+            end
+            site.pages << newpage
+          else
+            template.pager = pager
+          end
+        end
+      end # function paginate
+      
+      # Calculate the number of pages.
+      #
+      # all_posts - The Array of all Posts.
+      # per_page  - The Integer of entries per page.
+      #
+      # Returns the Integer number of pages.
+      def calculate_number_of_pages(all_posts, per_page)
+        (all_posts.size.to_f / per_page.to_i).ceil
+      end
+      
+    end # class PaginationV2
+
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/paginator.rb

@@ -0,0 +1,58 @@
+module Jekyll
+  module PaginateV2
+    
+    #
+    # Handles the preparation of all the posts based on the current page index
+    #
+    class PaginatorV2
+      attr_reader :page, :per_page, :posts, :total_posts, :total_pages,
+        :previous_page, :previous_page_path, :next_page, :next_page_path
+      
+      # Initialize a new Paginator.
+      #
+      # site     - the Jekyll::Site object
+      # page_nr  - The Integer page number.
+      # all_posts - The Array of all the site's Posts.
+      # num_pages - The Integer number of pages or nil if you'd like the number
+      #             of pages calculated.
+      def initialize(config, posts, cur_page_nr, num_pages, template )
+        @page = cur_page_nr
+        @per_page = config['per_page'].to_i
+        @total_pages = num_pages
+
+        if @page > @total_pages
+          raise RuntimeError, "page number can't be greater than total pages: #{@page} > #{@total_pages}"
+        end
+
+        init = (@page - 1) * @per_page
+        offset = (init + @per_page - 1) >= posts.size ? posts.size : (init + @per_page - 1)
+
+        @total_posts = posts.size
+        @posts = posts[init..offset]
+        @previous_page = @page != 1 ? @page - 1 : nil
+        @previous_page_path = Utils.paginate_path(template, @previous_page, config)
+        @next_page = @page != @total_pages ? @page + 1 : nil
+        @next_page_path = Utils.paginate_path(template, @next_page, config)
+      end
+
+      # Convert this Paginator's data to a Hash suitable for use by Liquid.
+      #
+      # Returns the Hash representation of this Paginator.
+      def to_liquid
+        {
+          'per_page' => per_page,
+          'posts' => posts,
+          'total_posts' => total_posts,
+          'total_pages' => total_pages,
+          'page' => page,
+          'previous_page' => previous_page,
+          'previous_page_path' => previous_page_path,
+          'next_page' => next_page,
+          'next_page_path' => next_page_path
+        }
+      end
+      
+    end # class PaginatorV2
+
+  end # module PaginateV2
+end # module Jekyll

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

@@ -0,0 +1,58 @@
+module Jekyll 
+  module PaginateV2
+
+    #
+    # Static utility functions that are used in the code and 
+    # don't belong in once place in particular
+    #
+    class Utils
+
+      # 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, cur_page_nr, config)
+        return nil if cur_page_nr.nil?
+        return template.url if cur_page_nr <= 1
+        format = config['permalink']
+        if format.include?(":num")
+          format = Utils.format_page_number(format, cur_page_nr)
+        else
+          raise ArgumentError.new("Invalid pagination path: '#{format}'. It must include ':num'.")
+        end
+        Utils.ensure_leading_slash(format)
+      end #function paginate_path
+      
+      # Static: returns a fully formatted string with the current page number if configured
+      #
+      def self.format_page_number(toFormat, cur_page_nr)
+        return toFormat.sub(':num', cur_page_nr.to_s)
+      end #function format_page_number
+      
+      # 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
+      #         returned unchanged.
+      #
+      # path - a String path
+      #
+      # Returns the path with a leading slash
+      def self.ensure_leading_slash(path)
+        path[0..0] == "/" ? path : "/#{path}"
+      end
+
+      # Static: Return a String version of the input without a leading slash.
+      #
+      # path - a String path
+      #
+      # Returns the input without the leading slash
+      def self.remove_leading_slash(path)
+        path[0..0] == "/" ? path[1..-1] : path
+      end
+
+    end
+
+  end # module PaginateV2
+end # module Jekyll

data/lib/jekyll-paginate-v2/version.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  module PaginateV2
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-paginate-v2
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sverrir Sigmundarson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: An enhanced in-place replacement for the previously built-in jekyll-paginate
+  gem offering full backwards compatability as well as a slew of new frequently requested
+  features
+email:
+- jekyll@sverrirs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- jekyll-paginate-v2.gemspec
+- lib/jekyll-paginate-v2.rb
+- lib/jekyll-paginate-v2/defaults.rb
+- lib/jekyll-paginate-v2/pagination.rb
+- lib/jekyll-paginate-v2/paginator.rb
+- lib/jekyll-paginate-v2/utils.rb
+- lib/jekyll-paginate-v2/version.rb
+homepage: https://github.com/sverrirs/jekyll-paginate-v2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Pagination Generator for Jekyll 3
+test_files: []