bridgetown-paginate 0.11.0 → 0.11.1

data/lib/bridgetown-paginate/pagination_page.rb

@@ -2,59 +2,56 @@
 
 module Bridgetown
   module Paginate
-    module 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 Bridgetown 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 < Bridgetown::Page
-        def initialize(page_to_copy, cur_page_nr, total_pages, index_pageandext, template_ext)
-          @site = page_to_copy.site
-          @base = ""
-          @url = ""
-          @name = index_pageandext.nil? ? "index#{template_ext}" : index_pageandext
-          @path = page_to_copy.path
+    #
+    # 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 Bridgetown 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 < Bridgetown::Page
+      def initialize(page_to_copy, cur_page_nr, total_pages, index_pageandext, template_ext)
+        @site = page_to_copy.site
+        @base = ""
+        @url = ""
+        @name = index_pageandext.nil? ? "index#{template_ext}" : index_pageandext
+        @path = page_to_copy.path
 
-          # Creates the basename and ext member values
-          process(@name)
+        # Creates the basename and ext member values
+        process(@name)
 
-          # Only need to copy the data part of the page as it already contains the
-          # layout information
-          self.data = Bridgetown::Utils.deep_merge_hashes page_to_copy.data, {}
-          if !page_to_copy.data["autopage"]
-            self.content = page_to_copy.content
-          elsif page_to_copy.data["autopage"].key?("display_name")
-            # 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)
-            data["autopages"] = Bridgetown::Utils.deep_merge_hashes(
-              page_to_copy.data["autopage"], {}
-            )
-          end
+        # Only need to copy the data part of the page as it already contains the
+        # layout information
+        self.data = Bridgetown::Utils.deep_merge_hashes page_to_copy.data, {}
+        if !page_to_copy.data["autopage"]
+          self.content = page_to_copy.content
+        elsif page_to_copy.data["autopage"].key?("display_name")
+          # 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)
+          data["autopages"] = Bridgetown::Utils.deep_merge_hashes(
+            page_to_copy.data["autopage"], {}
+          )
+        end
 
-          # Store the current page and total page numbers in the pagination_info construct
-          data["pagination_info"] = { "curr_page" => cur_page_nr, "total_pages" => total_pages }
+        # Store the current page and total page numbers in the pagination_info construct
+        data["pagination_info"] = { "curr_page" => cur_page_nr, "total_pages" => total_pages }
 
-          # Perform some validation that is also performed in Bridgetown::Page
-          validate_data! page_to_copy.path
-          validate_permalink! page_to_copy.path
+        # Perform some validation that is also performed in Bridgetown::Page
+        validate_data! page_to_copy.path
+        validate_permalink! page_to_copy.path
 
-          # TODO: Trigger a page event
-          # Bridgetown::Hooks.trigger :pages, :post_init, self
-        end
+        Bridgetown::Hooks.trigger :pages, :post_init, self
+      end
 
-        # rubocop:disable Naming/AccessorMethodName
-        def set_url(url_value)
-          @path = url_value.delete_prefix "/"
-          @dir  = File.dirname(@path)
-          @url = url_value
-        end
-        # rubocop:enable Naming/AccessorMethodName
+      # rubocop:disable Naming/AccessorMethodName
+      def set_url(url_value)
+        @path = url_value.delete_prefix "/"
+        @dir  = File.dirname(@path)
+        @url = url_value
       end
+      # rubocop:enable Naming/AccessorMethodName
     end
   end
 end

data/lib/bridgetown-paginate/paginator.rb

@@ -2,137 +2,135 @@
 
 module Bridgetown
   module Paginate
-    module Generator
-      #
-      # Handles the preparation of all the documents based on the current page index
+    #
+    # Handles the preparation of all the documents based on the current page index
+    #
+    class Paginator
+      attr_reader :page, :per_page, :documents, :total_documents, :total_pages,
+                  :previous_page, :previous_page_path, :next_page, :next_page_path, :page_path,
+                  :first_page, :first_page_path, :last_page, :last_page_path
+      attr_accessor :page_trail
+
+      # Initialize a new Paginator.
       #
-      class Paginator
-        attr_reader :page, :per_page, :documents, :total_documents, :total_pages,
-                    :previous_page, :previous_page_path, :next_page, :next_page_path, :page_path,
-                    :first_page, :first_page_path, :last_page, :last_page_path
-        attr_accessor :page_trail
+      def initialize(
+        config_per_page,
+        first_index_page_url,
+        paginated_page_url,
+        documents,
+        cur_page_nr,
+        num_pages,
+        default_indexpage,
+        default_ext
+      )
+        @page = cur_page_nr
+        @per_page = config_per_page.to_i
+        @total_pages = num_pages
 
-        # Initialize a new Paginator.
-        #
-        def initialize(
-          config_per_page,
-          first_index_page_url,
-          paginated_page_url,
-          documents,
-          cur_page_nr,
-          num_pages,
-          default_indexpage,
-          default_ext
-        )
-          @page = cur_page_nr
-          @per_page = config_per_page.to_i
-          @total_pages = num_pages
+        if @page > @total_pages
+          raise "page number can't be greater than total pages:" \
+            " #{@page} > #{@total_pages}"
+        end
 
-          if @page > @total_pages
-            raise "page number can't be greater than total pages:" \
-              " #{@page} > #{@total_pages}"
-          end
+        init = (@page - 1) * @per_page
+        offset = if init + @per_page - 1 >= documents.size
+                   documents.size
+                 else
+                   init + @per_page - 1
+                 end
 
-          init = (@page - 1) * @per_page
-          offset = if init + @per_page - 1 >= documents.size
-                     documents.size
-                   else
-                     init + @per_page - 1
-                   end
+        # Ensure that the current page has correct extensions if needed
+        this_page_url = Utils.ensure_full_path(
+          @page == 1 ? first_index_page_url : paginated_page_url,
+          !default_indexpage || default_indexpage.empty? ? "index" : default_indexpage,
+          !default_ext || default_ext.empty? ? ".html" : default_ext
+        )
 
-          # Ensure that the current page has correct extensions if needed
-          this_page_url = Utils.ensure_full_path(
-            @page == 1 ? first_index_page_url : paginated_page_url,
-            !default_indexpage || default_indexpage.empty? ? "index" : default_indexpage,
-            !default_ext || default_ext.empty? ? ".html" : default_ext
+        # To support customizable pagination pages we attempt to explicitly
+        # append the page name to the url incase the user is using extensionless permalinks.
+        if default_indexpage&.length&.positive?
+          # Adjust first page url
+          first_index_page_url = Utils.ensure_full_path(
+            first_index_page_url, default_indexpage, default_ext
           )
+          # Adjust the paginated pages as well
+          paginated_page_url = Utils.ensure_full_path(
+            paginated_page_url, default_indexpage, default_ext
+          )
+        end
 
-          # To support customizable pagination pages we attempt to explicitly
-          # append the page name to the url incase the user is using extensionless permalinks.
-          if default_indexpage&.length&.positive?
-            # Adjust first page url
-            first_index_page_url = Utils.ensure_full_path(
-              first_index_page_url, default_indexpage, default_ext
-            )
-            # Adjust the paginated pages as well
-            paginated_page_url = Utils.ensure_full_path(
-              paginated_page_url, default_indexpage, default_ext
-            )
-          end
-
-          @total_documents = documents.size
-          @documents = documents[init..offset]
-          @page_path = Utils.format_page_number(this_page_url, cur_page_nr, @total_pages)
+        @total_documents = documents.size
+        @documents = documents[init..offset]
+        @page_path = Utils.format_page_number(this_page_url, cur_page_nr, @total_pages)
 
-          @previous_page = @page != 1 ? @page - 1 : nil
-          @previous_page_path = unless @page == 1
-                                  if @page == 2
-                                    Utils.format_page_number(
-                                      first_index_page_url, 1, @total_pages
-                                    )
-                                  else
-                                    Utils.format_page_number(
-                                      paginated_page_url,
-                                      @previous_page,
-                                      @total_pages
-                                    )
-                                  end
+        @previous_page = @page != 1 ? @page - 1 : nil
+        @previous_page_path = unless @page == 1
+                                if @page == 2
+                                  Utils.format_page_number(
+                                    first_index_page_url, 1, @total_pages
+                                  )
+                                else
+                                  Utils.format_page_number(
+                                    paginated_page_url,
+                                    @previous_page,
+                                    @total_pages
+                                  )
                                 end
-          @next_page = @page != @total_pages ? @page + 1 : nil
-          @next_page_path = if @page != @total_pages
-                              Utils.format_page_number(
-                                paginated_page_url, @next_page, @total_pages
-                              )
-                            end
+                              end
+        @next_page = @page != @total_pages ? @page + 1 : nil
+        @next_page_path = if @page != @total_pages
+                            Utils.format_page_number(
+                              paginated_page_url, @next_page, @total_pages
+                            )
+                          end
 
-          @first_page = 1
-          @first_page_path = Utils.format_page_number(first_index_page_url, 1, @total_pages)
-          @last_page = @total_pages
-          @last_page_path = Utils.format_page_number(paginated_page_url, @total_pages, @total_pages)
-        end
+        @first_page = 1
+        @first_page_path = Utils.format_page_number(first_index_page_url, 1, @total_pages)
+        @last_page = @total_pages
+        @last_page_path = Utils.format_page_number(paginated_page_url, @total_pages, @total_pages)
+      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,
-            "documents"          => documents,
-            "total_documents"    => total_documents,
-            "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,
-            "first_page"         => first_page,
-            "first_page_path"    => first_page_path,
-            "last_page"          => last_page,
-            "last_page_path"     => last_page_path,
-            "page_trail"         => page_trail,
-          }
-        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,
+          "documents"          => documents,
+          "total_documents"    => total_documents,
+          "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,
+          "first_page"         => first_page,
+          "first_page_path"    => first_page_path,
+          "last_page"          => last_page,
+          "last_page_path"     => last_page_path,
+          "page_trail"         => page_trail,
+        }
       end
+    end
 
-      # Small utility class that handles individual pagination trails
-      # and makes them easier to work with in Liquid
-      class PageTrail
-        attr_reader :num, :path, :title
+    # 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
+      def initialize(num, path, title)
+        @num = num
+        @path = path
+        @title = title
+      end
 
-        def to_liquid
-          {
-            "num"   => num,
-            "path"  => path,
-            "title" => title,
-          }
-        end
+      def to_liquid
+        {
+          "num"   => num,
+          "path"  => path,
+          "title" => title,
+        }
       end
     end
   end

data/lib/bridgetown-paginate/utils.rb

@@ -2,136 +2,134 @@
 
 module Bridgetown
   module Paginate
-    module 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 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(to_format, cur_page_nr, total_page_count = nil)
-          s = to_format.sub(":num", cur_page_nr.to_s)
-          s = s.sub(":max", total_page_count.to_s) unless total_page_count.nil?
+      # 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(to_format, cur_page_nr, total_page_count = nil)
+        s = to_format.sub(":num", cur_page_nr.to_s)
+        s = s.sub(":max", total_page_count.to_s) unless total_page_count.nil?
 
-          s
-        end
+        s
+      end
 
-        # 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(to_format, title, cur_page_nr = nil, total_page_count = nil)
-          format_page_number(to_format.sub(":title", title.to_s), cur_page_nr, total_page_count)
-        end
+      # 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(to_format, title, cur_page_nr = nil, total_page_count = nil)
+        format_page_number(to_format.sub(":title", title.to_s), cur_page_nr, total_page_count)
+      end
 
-        # 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 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 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
 
-        # 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
+      #
+      # Sorting routine used for ordering posts by custom fields.
+      # Handles Strings separately as we want a case-insenstive sorting
+      #
+      # rubocop:disable Naming/MethodParameterName, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def self.sort_values(a, b)
+        if a.nil? && !b.nil?
+          return -1
+        elsif !a.nil? && b.nil?
+          return 1
         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}/"
+        return a.downcase <=> b.downcase if a.is_a?(String)
+
+        if a.respond_to?("to_datetime") && b.respond_to?("to_datetime")
+          return a.to_datetime <=> b.to_datetime
         end
 
-        #
-        # Sorting routine used for ordering posts by custom fields.
-        # Handles Strings separately as we want a case-insenstive sorting
-        #
-        # rubocop:disable Naming/MethodParameterName, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def self.sort_values(a, b)
-          if a.nil? && !b.nil?
-            return -1
-          elsif !a.nil? && b.nil?
-            return 1
-          end
-
-          return a.downcase <=> b.downcase if a.is_a?(String)
-
-          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
-          a <=> b
+        # By default use the built in sorting for the data type
+        a <=> b
+      end
+      # rubocop:enable Naming/MethodParameterName, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # 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
+          return nil unless sort_value.key?(key)
+
+          # Work my way through the hash
+          sort_value = sort_value[key]
         end
-        # rubocop:enable Naming/MethodParameterName, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        # 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
-            return nil unless sort_value.key?(key)
-
-            # 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)
-            nil
-          else
-            sort_value
-          end
+
+        # If the sort value is a hash then return nil else return the value
+        if sort_value.is_a?(Hash)
+          nil
+        else
+          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?("/")
-            url + default_index + default_ext
-          elsif !url.include?(".")
-            url + default_index
-          else
-            url
-          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?("/")
+          url + default_index + default_ext
+        elsif !url.include?(".")
+          url + default_index
+        else
+          url
         end
       end
     end