j1_paginator 2019.1.0

data/lib/j1_paginator/generator/utils.rb

@@ -0,0 +1,181 @@
+module Jekyll 
+  module J1Paginator::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 dot.
+      #         If the input already has a dot in position zero, it will be
+      #         returned unchanged.
+      #
+      # path - a String path
+      #
+      # Returns the path with a leading slash
+      def self.ensure_leading_dot(path)
+        path[0..0] == "." ? path : ".#{path}"
+      end
+      
+      # 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.nil? && !b.nil?
+          return -1
+        elsif !a.nil? && b.nil?
+          return 1
+        end
+
+        if a.is_a?(String)
+          return a.downcase <=> b.downcase
+        end
+
+        if a.respond_to?('to_datetime') && b.respond_to?('to_datetime')
+          return a.to_datetime <=> b.to_datetime
+        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
+
+        sort_split.each do |r_key|
+          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
+
+      # Ensures that the passed in url has a index and extension applied
+      def self.ensure_full_path(url, default_index, default_ext)
+        if( url.end_with?('/'))
+          return url + default_index + default_ext
+        elsif !url.include?('.')
+          return url + default_index
+        end
+        # Default
+        return url
+      end
+
+      # Constructs the plural for a key
+      def self.plural(config_key)
+        (config_key =~ /s$/) ? config_key :
+          (config_key.dup.sub!(/y$/, 'ies') || "#{config_key}s")
+      end
+
+      # Converts a string or array to a downcased, stripped array
+      def self.config_array(config, key, keepcase = nil)
+        [ config[key] ].flatten.compact.uniq.map { |c|
+          c.split(/[,;]\s*/).map { |v|
+            keepcase ? v.to_s.strip : v.to_s.downcase.strip
+          }
+        }.flatten.uniq
+      end
+
+      # Merges singular and plural config values into an array
+      def self.config_values(config, key, keepcase = nil)
+        singular = config_array(config, key, keepcase)
+        plural = config_array(config, plural(key), keepcase)
+        [ singular, plural ].flatten.uniq
+      end
+
+      def self.validate_url(template)
+        url  = template.url
+        ext  = template.output_ext
+        path = Jekyll::URL.unescape_path(url)
+        path = File.join(path, "index") if url.end_with?("/")
+        path << ext unless path.end_with?(ext)
+
+        dirname = File.dirname(path)
+        valid_values = [
+          File.join(dirname, "/"),
+          File.join(dirname, "index#{ext}")
+        ]
+
+        return url if valid_values.include?(url)
+        Jekyll.logger.error "Pagination Error:",
+          "Detected invalid url #{url.inspect} for #{template.relative_path.inspect}"
+        Jekyll.logger.abort_with "", "Expected #{valid_values.map(&:inspect).join(' or ')}"
+      end
+    end
+
+  end # module J1Paginator
+end # module Jekyll

data/lib/j1_paginator/version.rb

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

data/spec/generator/defaults_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::J1Paginator::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::J1Paginator::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,197 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::J1Paginator::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, 'index', '.html')
+
+      # 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, 'index', '.html') }.must_raise RuntimeError
+
+      # No error should be raised below
+      pager = Paginator.new(10, "index.html", "/page:num/", [], 8, 10, 'index', '.html')
+    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 1 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 5 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
+
+    it "must create the explicit index page and index extension when specified" 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, 'index', '.html')
+
+      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/index.html'
+    end
+
+    it "must create the explicit index page and index extension when specified" 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, "/", "/", posts, 2, 5, 'feed:num', '.json')
+
+      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 '/feed1.json'
+      pager.next_page.must_equal 3
+      pager.next_page_path.must_equal '/feed3.json'
+    end
+
+  end
+end

data/spec/generator/utils_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../spec_helper.rb'
+
+module Jekyll::J1Paginator::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
+