jekyll-paginate-v2-redux 1.7.6

data/lib/jekyll-paginate-v2-redux/generator/paginationPage.rb

@@ -0,0 +1,50 @@
+module Jekyll
+  module PaginateV2::Generator
+
+    #
+    # This page handles the creation of the fake pagination pages based on the original page configuration
+    # The code does the same things as the default Jekyll/page.rb code but just forces the code to look
+    # into the template instead of the (currently non-existing) pagination page.
+    #
+    # This page exists purely in memory and is not read from disk
+    #
+    class PaginationPage < Page
+      def initialize(page_to_copy, cur_page_nr, total_pages)
+        @site = page_to_copy.site
+        @base = ''
+        @url = ''
+        @name = 'index.html'
+
+        self.process(@name) # Creates the basename and ext member values
+
+        # Only need to copy the data part of the page as it already contains the layout information
+        #self.data = Marshal.load(Marshal.dump(page_to_copy.data)) # Deep copying, http://stackoverflow.com/a/8206537/779521
+        self.data = Jekyll::Utils.deep_merge_hashes( page_to_copy.data, {} )
+        if !page_to_copy.data['autopage']
+          self.content = page_to_copy.content
+        else
+          # If the page is an auto page then migrate the necessary autopage info across into the
+          # new pagination page (so that users can get the correct keys etc)
+          if( page_to_copy.data['autopage'].has_key?('display_name') )
+            self.data['autopages'] = Jekyll::Utils.deep_merge_hashes( page_to_copy.data['autopage'], {} )
+          end
+        end
+
+        # Store the current page and total page numbers in the pagination_info construct
+        self.data['pagination_info'] = {"curr_page" => cur_page_nr, 'total_pages' => total_pages }
+
+        # Perform some validation that is also performed in Jekyll::Page
+        validate_data! page_to_copy.path
+        validate_permalink! page_to_copy.path
+
+        # Trigger a page event
+        #Jekyll::Hooks.trigger :pages, :post_init, self
+      end
+
+      def set_url(url_value)
+        @url = url_value
+      end
+    end # class PaginationPage
+
+  end # module PaginateV2
+end # module Jekyll

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

@@ -0,0 +1,84 @@
+module Jekyll
+  module PaginateV2::Generator
+    
+    #
+    # Handles the preparation of all the posts based on the current page index
+    #
+    class Paginator
+      attr_reader :page, :per_page, :posts, :total_posts, :total_pages,
+        :previous_page, :previous_page_path, :next_page, :next_page_path, :page_path, :page_trail
+
+      def page_trail
+        @page_trail
+      end
+
+      def page_trail=(page_array)
+        @page_trail = page_array
+      end
+      
+      # Initialize a new Paginator.
+      #
+      def initialize(config_per_page, first_index_page_url, paginated_page_url, posts, cur_page_nr, num_pages)
+        @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]
+        @page_path = @page == 1 ? first_index_page_url : Utils.format_page_number(paginated_page_url, cur_page_nr, @total_pages)
+        @previous_page = @page != 1 ? @page - 1 : nil
+        @previous_page_path = @page != 1 ? @page == 2 ? first_index_page_url : Utils.format_page_number(paginated_page_url, @previous_page, @total_pages) : nil
+        @next_page = @page != @total_pages ? @page + 1 : nil
+        @next_page_path = @page != @total_pages ? Utils.format_page_number(paginated_page_url, @next_page, @total_pages) : nil
+      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,
+          'page_path' => page_path,
+          'previous_page' => previous_page,
+          'previous_page_path' => previous_page_path,
+          'next_page' => next_page,
+          'next_page_path' => next_page_path,
+          'page_trail' => page_trail
+        }
+      end
+      
+    end # class Paginator
+
+    # Small utility class that handles individual pagination trails 
+    # and makes them easier to work with in Liquid
+    class PageTrail
+      attr_reader :num, :path, :title
+
+      def initialize( num, path, title )
+        @num = num
+        @path = path
+        @title = title
+      end #func initialize
+
+      def to_liquid
+        {
+          'num' => num,
+          'path' => path+"index.html",
+          'title' => title
+        }
+      end
+    end #class PageTrail
+
+  end # module PaginateV2
+end # module Jekyll

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

@@ -0,0 +1,109 @@
+module Jekyll 
+  module PaginateV2::Generator
+
+    #
+    # Static utility functions that are used in the code and 
+    # don't belong in once place in particular
+    #
+    class Utils
+
+      # Static: 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 self.calculate_number_of_pages(all_posts, per_page)
+        (all_posts.size.to_f / per_page.to_i).ceil
+      end
+
+      # Static: returns a fully formatted string with the current (:num) page number and maximum (:max) page count replaced if configured
+      #
+      def self.format_page_number(toFormat, cur_page_nr, total_page_count=nil)
+        s = toFormat.sub(':num', cur_page_nr.to_s)
+        if !total_page_count.nil?
+          s = s.sub(':max', total_page_count.to_s)
+        end
+        return s
+      end #function format_page_number
+
+      # Static: returns a fully formatted string with the :title variable and the current (:num) page number and maximum (:max) page count replaced
+      #
+      def self.format_page_title(toFormat, title, cur_page_nr=nil, total_page_count=nil)
+        return format_page_number(toFormat.sub(':title', title.to_s), cur_page_nr, total_page_count)
+      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
+      #         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
+      
+      # Static: Return a String version of the input which has a trailing slash.
+      #         If the input already has a forward slash at the end, it will be
+      #         returned unchanged.
+      #
+      # path - a String path
+      #
+      # Returns the path with a trailing slash
+      def self.ensure_trailing_slash(path)
+        path[-1] == "/" ? path : "#{path}/"
+      end
+
+      #
+      # Sorting routine used for ordering posts by custom fields.
+      # Handles Strings separately as we want a case-insenstive sorting
+      #
+      def self.sort_values(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
+
+      # 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_data, sort_field)
+        
+        # Begin by splitting up the sort_field by (;,:.)
+        sort_split = sort_field.split(":")
+        sort_value = post_data
+
+        for r_key in sort_split
+          key = r_key.downcase.strip # Remove any erronious whitespace and convert to lower case
+          if !sort_value.has_key?(key)
+            return nil
+          end
+          # Work my way through the hash
+          sort_value = sort_value[key]
+        end
+
+        # If the sort value is a hash then return nil else return the value
+        if( sort_value.is_a?(Hash) )
+          return nil
+        else
+          return sort_value
+        end
+      end
+
+    end
+
+  end # module PaginateV2
+end # module Jekyll

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

@@ -0,0 +1,10 @@
+module Jekyll
+  module PaginateV2
+    VERSION = "1.7.6"
+    # When modifying remember to issue a new tag command in git before committing, then push the new tag
+    #   git tag -a v1.7.6 -m "Gem v1.7.6"
+    #   git push origin --tags
+    # Yanking a published Gem
+    #   gem yank jekyll-paginate-v2 -v VERSION
+  end # module PaginateV2
+end # module Jekyll

data/spec/generator/defaults_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::PaginateV2::Generator
+  describe "checking default config" do
+
+    it "should always contain the following keys" do
+      DEFAULT.must_include 'enabled'
+      DEFAULT.must_include 'collection'
+      DEFAULT.must_include 'per_page'
+      DEFAULT.must_include 'permalink'
+      DEFAULT.must_include 'title'
+      DEFAULT.must_include 'page_num'
+      DEFAULT.must_include 'sort_reverse'
+      DEFAULT.must_include 'sort_field'
+      DEFAULT.must_include 'limit'
+      DEFAULT.must_include 'debug'
+      DEFAULT.size.must_be :>=, 10
+    end
+
+    it "should always contain the following key defaults" do
+      DEFAULT['enabled'].must_equal false
+      DEFAULT['collection'].must_equal 'posts'
+      DEFAULT['per_page'].must_equal 10
+      DEFAULT['permalink'].must_equal '/page:num/'
+      DEFAULT['title'].must_equal ':title - page :num'
+      DEFAULT['page_num'].must_equal 1
+      DEFAULT['sort_reverse'].must_equal false
+      DEFAULT['sort_field'].must_equal 'date'
+      DEFAULT['limit'].must_equal 0
+      DEFAULT['debug'].must_equal false
+    end
+
+  end
+end

data/spec/generator/paginationPage_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::PaginateV2::Generator
+  describe "tesing pagination page implementation" do
+
+    it "sould always read the template file into itself" do
+      # DUE TO THE JEKYLL:PAGE CLASS ACCESSING FILE IO DIRECTLY 
+      # I AM UNABLE TO MOCK OUT THE FILE OPERATIONS TO CREATE UNIT TESTS FOR THIS CLASS :/
+    end
+
+  end
+end

data/spec/generator/paginator_spec.rb

@@ -0,0 +1,107 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::PaginateV2::Generator
+  describe Paginator do
+
+    it "must include the necessary paginator attributes" do
+
+      #  config_per_page, first_index_page_url, paginated_page_url, posts, cur_page_nr, num_pages
+      pager = Paginator.new(10, "index.html", "/page:num/", [], 1, 10)
+
+      # None of these accessors should throw errors, just run through them to test
+      val = pager.page
+      val = pager.per_page
+      val = pager.posts
+      val = pager.total_posts
+      val = pager.total_pages
+      val = pager.previous_page
+      val = pager.previous_page_path
+      val = pager.next_page
+      val = pager.next_page_path
+      
+    end
+
+    it "must throw an error if the current page number is greater than the total pages" do
+      err = -> { pager = Paginator.new(10, "index.html", "/page:num/", [], 10, 8) }.must_raise RuntimeError
+
+      # No error should be raised below
+      pager = Paginator.new(10, "index.html", "/page:num/", [], 8, 10)
+    end
+
+    it "must trim the list of posts correctly based on the cur_page_nr and per_page" do
+      # Create a dummy list of posts that is easy to track
+      posts = ['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35']
+
+      # Initialize a pager with
+      #   5 posts per page
+      #   at page 2 out of 5 pages
+      pager = Paginator.new(5, "index.html", "/page:num/", posts, 2, 5)
+
+      pager.page.must_equal 2
+      pager.per_page.must_equal 5
+      pager.total_pages.must_equal 5
+
+      pager.total_posts.must_equal 35
+
+      pager.posts.size.must_equal 5
+      pager.posts[0].must_equal '6'
+      pager.posts[4].must_equal '10'
+
+      pager.previous_page.must_equal 1
+      pager.previous_page_path.must_equal 'index.html'
+      pager.next_page.must_equal 3
+      pager.next_page_path.must_equal '/page3/'
+    end
+
+    it "must not create a previous page if we're at first page" do
+      # Create a dummy list of posts that is easy to track
+      posts = ['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35']
+
+      # Initialize a pager with
+      #   5 posts per page
+      #   at page 2 out of 5 pages
+      pager = Paginator.new(5, "index.html", "/page:num/", posts, 1, 5)
+
+      pager.page.must_equal 1
+      pager.per_page.must_equal 5
+      pager.total_pages.must_equal 5
+
+      pager.total_posts.must_equal 35
+
+      pager.posts.size.must_equal 5
+      pager.posts[0].must_equal '1'
+      pager.posts[4].must_equal '5'
+
+      pager.previous_page.must_be_nil
+      pager.previous_page_path.must_be_nil
+      pager.next_page.must_equal 2
+      pager.next_page_path.must_equal '/page2/'
+    end
+
+    it "must not create a next page if we're at the final page" do
+      # Create a dummy list of posts that is easy to track
+      posts = ['1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32','33','34','35']
+
+      # Initialize a pager with
+      #   5 posts per page
+      #   at page 2 out of 5 pages
+      pager = Paginator.new(5, "index.html", "/page:num/", posts, 5, 5)
+
+      pager.page.must_equal 5
+      pager.per_page.must_equal 5
+      pager.total_pages.must_equal 5
+
+      pager.total_posts.must_equal 35
+
+      pager.posts.size.must_equal 5
+      pager.posts[0].must_equal '21'
+      pager.posts[4].must_equal '25'
+
+      pager.previous_page.must_equal 4
+      pager.previous_page_path.must_equal '/page4/'
+      pager.next_page.must_be_nil
+      pager.next_page_path.must_be_nil
+    end
+
+  end
+end

data/spec/generator/utils_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::PaginateV2::Generator
+  describe Utils do
+
+    it "should always replace num format with the specified number" do
+      Utils.format_page_number( ":num", 7).must_equal "7"
+      Utils.format_page_number( ":num", 13).must_equal "13"
+      Utils.format_page_number( ":num", -2).must_equal "-2"
+      Utils.format_page_number( ":num", 0).must_equal "0"
+      Utils.format_page_number( ":num", 1000).must_equal "1000"
+    end
+
+    it "should always replace num format with the specified number and keep rest of formatting" do
+      Utils.format_page_number( "/page:num/", 7).must_equal "/page7/"
+      Utils.format_page_number( "/page:num/", 50).must_equal "/page50/"
+      Utils.format_page_number( "/page:num/", -5).must_equal "/page-5/"
+
+      Utils.format_page_number( "/car/:num/", 1).must_equal "/car/1/"
+      Utils.format_page_number( "/car/:num", 1).must_equal "/car/1"
+      Utils.format_page_number( "car/:num", 1).must_equal "car/1"
+      Utils.format_page_number( "/car//:num", 1).must_equal "/car//1"
+    end
+
+    it "make sure there is a leading slash in path" do
+      Utils.ensure_leading_slash("path/to/file/wow").must_equal "/path/to/file/wow"
+      Utils.ensure_leading_slash("/no/place/wow/").must_equal "/no/place/wow/"
+      Utils.ensure_leading_slash("/no").must_equal "/no"
+      Utils.ensure_leading_slash("no").must_equal "/no"
+    end    
+
+    it "make sure there is never a leading slash in path" do
+      Utils.remove_leading_slash("path/to/file/wow").must_equal "path/to/file/wow"
+      Utils.remove_leading_slash("/no/place/wow/").must_equal "no/place/wow/"
+      Utils.remove_leading_slash("/no").must_equal "no"
+      Utils.remove_leading_slash("no").must_equal "no"
+    end
+
+    it "sort must sort strings lowercase" do
+      Utils.sort_values( "AARON", "Aaron").must_equal 0
+      Utils.sort_values( "AARON", "aaron").must_equal 0
+      Utils.sort_values( "aaron", "AARON").must_equal 0 
+    end
+
+    it "when sorting by nested post data the values must be resolved fully" do
+      data = {'book'=>{ 'name' => { 'first'=> 'John', 'last'=> 'Smith'}, 'rank'=>20}}
+      Utils.sort_get_post_data(data, "book:rank").must_equal 20
+      Utils.sort_get_post_data(data, "book:name:first").must_equal "John"
+      Utils.sort_get_post_data(data, "book:name:last").must_equal "Smith"
+
+      Utils.sort_get_post_data(data, "book:name").must_be_nil
+      Utils.sort_get_post_data(data, "name").must_be_nil
+      Utils.sort_get_post_data(data, "book").must_be_nil
+    end
+
+    it "should always replace max format with the specified number if specified" do
+      Utils.format_page_number( ":num-:max", 7, 16).must_equal "7-16"
+      Utils.format_page_number( ":num-:max", 13, 20).must_equal "13-20"
+      Utils.format_page_number( ":num-:max", -2, -4).must_equal "-2--4"
+      Utils.format_page_number( ":num_of_:max", 0, 10).must_equal "0_of_10"
+      Utils.format_page_number( ":num/:max", 1000, 2000).must_equal "1000/2000"
+    end
+
+
+  end
+end
+