jekyll-auto-authors 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 793a2713c64a6ae7a275644ee7ee7220bfab67449be05787ac5e0d9ffbba2106
+  data.tar.gz: 5a7686a785ed8f884b13b09b07bef2fb55e027b64c5187bf2ce25bc1690a4bab
+SHA512:
+  metadata.gz: 10e376f3581c57032f8e8873bc6714c8eb8a5e709367f58a3d1d26444cf7d87e41c447c04f4076c78ecd614d5dd6aed6a0b9d3a27da0f5c6e9411110fe6a83e8
+  data.tar.gz: e1fb701aa1878fa917aa5d029954f0276d51dfd9d7d59f06d9db9f39d5b722d38aa4fa8bda55747981bf57b8ffbd34a5f3ac02e6ea4c6c5ca32191cad6e8f807

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem"s dependencies in jekyll-paginate-authors.gemspec
+gemspec

data/jekyll-auto-authors.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-auto-authors/version"
+require "date"
+
+Gem::Specification.new do |spec|
+  spec.name          = "jekyll-auto-authors"
+  spec.version       = Jekyll::AutoAuthors::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.required_ruby_version = ">= 2.0.0"  # Same as Jekyll
+  spec.date          = DateTime.now.strftime("%Y-%m-%d")
+  spec.authors       = ["Gourav Khunger"]
+  spec.email         = ["gouravkhunger18@gmail.com"]
+  spec.homepage      = "https://github.com/gouravkhunger/jekyll-auto-authors"
+  spec.license       = "MIT"
+
+  spec.summary       = "Seamless multiple authors support for jekyll powered publications"
+  spec.description   = "A plugin to seamlessly support multiple authors with paginated posts inside a jekyll powered publication blog. Extends jekyll-paginate-v2 for Autopages and Pagination."
+
+  spec.files          = Dir["*.gemspec", "Gemfile", "lib/**/*"]
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_runtime_dependency "jekyll", ">= 3.0.0"
+  spec.add_runtime_dependency "jekyll-paginate-v2", ">= 3.0.0"
+  spec.add_development_dependency "bundler", ">= 2.0.0"
+end

data/lib/jekyll-auto-authors/authorAutoPage.rb

@@ -0,0 +1,35 @@
+module Jekyll
+  module AutoAuthors
+
+    class AuthorAutoPage < PaginateV2::AutoPages::BaseAutoPage
+      def initialize(site, base, autopage_config, pagination_config, layout_name, author, author_name)
+
+        # Get the slugify configuration if available.
+        slugify_config = autopage_config.is_a?(Hash) && autopage_config.has_key?("slugify") ? autopage_config["slugify"] : nil
+
+        # Construct the lambda function to set the config values this
+        # function receives the pagination config hash and manipulates it.
+        set_autopage_data_lambda = lambda do | in_config |
+          author_data = YAML::load(File.read(autopage_config["data"]))
+          in_config["author"] = author
+          in_config["author_data"] = author_data[author_name]
+        end
+
+        # Lambdas to return formatted permalink and title.
+        get_autopage_permalink_lambda = lambda do |permalink_pattern|
+          return Utils.format_author_macro(permalink_pattern, author, slugify_config)
+        end
+
+        get_autopage_title_lambda = lambda do |title_pattern|
+          return Utils.format_author_macro(title_pattern, author, slugify_config)
+        end
+                
+        # Call the super constuctor from the base generator with our custom lambda.
+        super(site, base, autopage_config, pagination_config, layout_name, set_autopage_data_lambda, get_autopage_permalink_lambda, get_autopage_title_lambda, author_name)
+        
+      end
+
+    end
+    
+  end
+end

data/lib/jekyll-auto-authors/defaults.rb

@@ -0,0 +1,21 @@
+module Jekyll
+  module AutoAuthors
+
+    # Default configurations for the plugin.
+    DEFAULT = {
+      "enabled" => false, # Enable or disable the plugin.
+
+      "data" => "_data/authors.yml", # The data file inside _data/ folder that contains author information.
+      "layouts" => ["authors.html"], # The layout file inside _layouts/ folder to use for the author pages.
+
+      "title" => "Posts by :author", # :author is replaced by author name.
+      "permalink" => "/author/:author", # :author is customizable elements
+
+      "slugify" => {
+        "mode" => "none", # [raw, default, pretty, ascii or latin], none gives back the same string.
+        "cased" => false, # If cased is true, all uppercase letters in the result string are replaced with their lowercase counterparts.
+      }
+    }
+
+  end
+end

data/lib/jekyll-auto-authors/main.rb

@@ -0,0 +1,262 @@
+module Jekyll
+  module AutoAuthors
+
+    # The entrypoint for the plugin, auto called by Jekyll based on priorities.
+    # :lowest - after all the plugins are done with their thing.
+    class AuthorPageGenerator < Generator
+      safe true
+      priority :lowest
+
+      def generate(site)
+        # load the configs for jekyll-paginate-v2.
+        autopage_config = Jekyll::Utils.deep_merge_hashes(PaginateV2::AutoPages::DEFAULT, site.config["autopages"] || {})
+        pagination_config = Jekyll::Utils.deep_merge_hashes(PaginateV2::Generator::DEFAULT, site.config["pagination"] || {})
+
+        # load the configs for jekyll-auto-authors (this plugin).
+        authors_config = Jekyll::Utils.deep_merge_hashes(DEFAULT, site.config["autopages"]["authors"] || {})
+
+        # Do nothing if autopages / author config is disabled.
+        if (
+          autopage_config["enabled"].nil? ||
+          !autopage_config["enabled"] ||
+          authors_config["enabled"].nil? ||
+          !authors_config["enabled"]
+        )
+          Jekyll.logger.info "Author Pages:", "Disabled / Not configured properly."
+          return
+        end
+
+        Jekyll.logger.info "Author Pages:", "Generating..."
+
+        # Lambda that created the author page for a given author.
+        # will be passed to PaginateV2::Autopages for processing.
+        createauthorpage_lambda = lambda do | autopage_author_config, pagination_config, layout_name, author, author_original_name |
+          author_data = YAML::load(File.read(autopage_author_config["data"]))[author_original_name]
+
+          if author_data.nil?
+            Jekyll.logger.warn "Author Pages:", "Author data for "#{author_original_name}" not found. Skipping author page..."
+            return
+          end
+
+          site.pages << AuthorAutoPage.new(site, site.dest, autopage_author_config, pagination_config, layout_name, author, author_original_name)
+        end
+
+        posts_to_use = []
+        site.collections.each do |coll_name, coll_data|
+          if !coll_data.nil?
+            # Exclude all pagination pages, as they are not posts.
+            # Then for every page store it"s collection name.
+
+            posts_to_use += coll_data.docs.select { |doc| !doc.data.has_key?("pagination") }.each{ |doc| doc.data["__coll"] = coll_name }
+          end
+        end
+
+        # Pass the config to PaginateV2::AutoPages for processing.
+        # autopage_create() indexes the posts into hashes by author (5th parameter here).
+        # then checkes if configs are enabled and if so, calls the lambda to generate the author page.
+        PaginateV2::AutoPages.autopage_create(
+          autopage_config, pagination_config, posts_to_use, "authors", "author", createauthorpage_lambda
+        )
+
+        # Now auto pages for authors have been created, we can generate the pagination logic.
+
+        # Further logic is mostly similar as PaginateV2::Generator::PaginationModel#paginate(), but we need
+        # to override the default pagination logic to include author pages too, so it isn"t called directly.
+
+        # Generate lambda for adding/deleting pages to the site.
+        page_add_lambda = lambda do | newpage |
+          site.pages << newpage
+          return newpage
+        end
+
+        page_remove_lambda = lambda do | page_to_remove |
+          site.pages.delete_if {|page| page == page_to_remove } 
+        end
+
+        # Logs formatted messages, defined similar to the one in PaginateV2::Generator::PaginationModel.
+        logging_lambda = lambda do | message, type = "info" |
+          if type == "debug"
+            Jekyll.logger.debug "Author Pages:","#{message}"
+          elsif type == "error"
+            Jekyll.logger.error "Author Pages:", "#{message}"
+          elsif type == "warn"
+            Jekyll.logger.warn "Author Pages:", "#{message}"
+          else
+            Jekyll.logger.info "Author Pages:", "#{message}"
+          end
+        end
+
+        # Create an instance of pagination model. We will use some functions from this instance while
+        # defining some logic of our own, for overriding the default pagination to include author pages too.
+        pagination_model = Jekyll::PaginateV2::Generator::PaginationModel.new(
+          logging_lambda, page_add_lambda, page_remove_lambda, nil
+        )
+
+        # get posts which have pagination enabled. Ignore hidden posts.
+        all_posts = site.collections["posts"].docs.select { |doc| !doc.data.has_key?("pagination") }
+        all_posts = all_posts.reject { |doc| doc["hidden"] }
+
+        # The Indexer is responsible for generating the hash for posts indexed by by author.
+        # The structure is: {"author1" => {<posts>}, "author2" => {<posts>}, ...}
+        posts_by_authors = Jekyll::PaginateV2::Generator::PaginationIndexer.index_posts_by(all_posts, "author")
+
+        # This gets all the pages where pagination is enabled. This also includes Autopages too, 
+        # as pagination data is assigned to them while generation (PaginateV2::AutoPages::BaseAutoPage line 45).
+        templates = pagination_model.discover_paginate_templates(site.pages)
+
+        templates.each do |template|
+          if template.data["pagination"].is_a?(Hash)
+
+            # For each template get the config, skip if paginatio is disabled, or it"s not an author page.
+            config = Jekyll::Utils.deep_merge_hashes(pagination_config, template.data["pagination"] || {})
+            next if !config["enabled"]
+            next if template.data["pagination"]["author"].nil?
+
+            # Filter posts with bad configs.
+            pagination_posts = PaginateV2::Generator::PaginationIndexer.read_config_value_and_filter_posts(
+              config, "author", all_posts, posts_by_authors
+            )
+
+            # 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
+
+              pagination_posts.each do |post|
+                if post.respond_to?("date")
+                  tmp_date = post.date
+                  if( !tmp_date || tmp_date.nil? )
+                    post.date = File.mtime(post.path)
+                  end
+                end
+              end
+
+              pagination_posts.sort!{ |a,b| 
+                PaginateV2::Generator::Utils.sort_values(
+                  PaginateV2::Generator::Utils.sort_get_post_data(a.data, sort_field), PaginateV2::Generator::Utils.sort_get_post_data(b.data, sort_field)
+                )
+              }
+
+              # Remove the first x entries. Defined by "offset" in the config.
+              offset_post_count = [0, config["offset"].to_i].max
+              pagination_posts.pop(offset_post_count)
+
+              if config["sort_reverse"]
+                pagination_posts.reverse!
+              end
+            end
+
+            # Calculate number of total pages.
+            total_pages = (pagination_posts.size.to_f / config["per_page"].to_i).ceil
+
+            # 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
+
+            # Remove the template page from the site, index pages will be generated in the next steps.
+            page_remove_lambda.call(template)
+            
+            # Store List of all newly created pages, used in creating pagination trails later.
+            newpages = []
+
+            # Consider the default index page name and extension.
+            indexPageName = config["indexpage"].nil? ? "" : config["indexpage"].split(".")[0]
+            indexPageExt =  config["extension"].nil? ? "" : Jekyll::PaginateV2::Generator::Utils.ensure_leading_dot(config["extension"])
+            indexPageWithExt = indexPageName + indexPageExt
+
+            total_pages = 1 if total_pages.zero?
+
+            (1..total_pages).each do |cur_page_nr|
+              # Create a new page for each page number.
+              newpage = Jekyll::PaginateV2::Generator::PaginationPage.new( template, cur_page_nr, total_pages, indexPageWithExt )
+
+              # Create the permalink for the in-memory page, construct title, set all page.data values needed.
+              paginated_page_url = config["permalink"]
+              first_index_page_url = ""
+              if template.data["permalink"]
+                first_index_page_url = Jekyll::PaginateV2::Generator::Utils.ensure_trailing_slash(template.data["permalink"])
+              else
+                first_index_page_url = Jekyll::PaginateV2::Generator::Utils.ensure_trailing_slash(template.dir)
+              end
+              paginated_page_url = File.join(first_index_page_url, paginated_page_url)
+              
+              # Create the pager logic for this page, pass in the prev and next page numbers, assign pager to in-memory page.
+              newpage.pager = PaginateV2::Generator::Paginator.new( config["per_page"], first_index_page_url, paginated_page_url, pagination_posts, cur_page_nr, total_pages, indexPageName, indexPageExt)
+
+              # Create the url for the new page, make sure to prepend any permalinks that are defined in the template page before.
+              if newpage.pager.page_path.end_with? "/"
+                newpage.set_url(File.join(newpage.pager.page_path, indexPageWithExt))
+              elsif newpage.pager.page_path.end_with? indexPageExt
+                # Support for direct .html files.
+                newpage.set_url(newpage.pager.page_path)
+              else
+                # Support for extensionless permalinks.
+                newpage.set_url(newpage.pager.page_path + indexPageExt)
+              end
+
+              if( template.data["permalink"] )
+                newpage.data["permalink"] = newpage.pager.page_path
+              end
+
+              # Transfer the title across to the new page.
+              if( !template.data["title"] )
+                tmp_title = site.title
+              else
+                tmp_title = template.data["title"]
+              end
+
+              # If the user specified a title suffix to be added then add that to all the pages except the first.
+              if( cur_page_nr > 1 && config.has_key?("title") )
+                newpage.data["title"] = "#{Jekyll::PaginateV2::Generator::Utils.format_page_title(config["title"], tmp_title, cur_page_nr, total_pages)}"
+              else
+                newpage.data["title"] = tmp_title
+              end
+
+              # Signals that this page is automatically generated by the pagination logic.
+              # We don"t do this for the first page as it is there to mask the one we removed.
+              if cur_page_nr > 1
+                newpage.data["autogen"] = "jekyll-paginate-v2"
+              end
+              
+              # Add the page to the site.
+              page_add_lambda.call( newpage )
+
+              # Store the page to the internal list.
+              newpages << newpage
+            end
+
+            # Now generate the pagination number path, so that the users can have a prev 1 2 3 4 5 next structure on their page
+            # simplest is to include all of the links to the pages preceeding the current one
+            # (e.g for page 1 you get the list 2, 3, 4.... and for page 2 you get the list 3,4,5...)
+            if( config["trail"] && !config["trail"].nil? && newpages.size.to_i > 1 )
+              trail_before = [config["trail"]["before"].to_i, 0].max
+              trail_after = [config["trail"]["after"].to_i, 0].max
+              trail_length = trail_before + trail_after + 1
+
+              if( trail_before > 0 || trail_after > 0 )
+                newpages.select do | npage |
+                  idx_start = [ npage.pager.page - trail_before - 1, 0].max # Selecting the beginning of the trail
+                  idx_end = [idx_start + trail_length, newpages.size.to_i].min # Selecting the end of the trail
+
+                  # Always attempt to maintain the max total of <trail_length> pages in the trail (it will look better if the trail doesn"t shrink).
+                  if( idx_end - idx_start < trail_length )
+                    # Attempt to pad the beginning if we have enough pages.
+                    idx_start = [idx_start - ( trail_length - (idx_end - idx_start) ), 0].max
+                    # Never go beyond the zero index.
+                  end              
+
+                  # Convert the newpages array into a two dimensional array that has [index, page_url] as items.
+                  npage.pager.page_trail = newpages[idx_start...idx_end].each_with_index.map {|ipage,idx| Jekyll::PaginateV2::Generator::PageTrail.new(idx_start+idx+1, ipage.pager.page_path, ipage.data["title"])}
+
+                end
+              end
+            end
+
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/lib/jekyll-auto-authors/utils.rb

@@ -0,0 +1,15 @@
+module Jekyll
+  module AutoAuthors
+
+    class Utils
+
+      def self.format_author_macro(toFormat, author, slugify_config=nil)
+        slugify_mode = slugify_config.has_key?("mode") ? slugify_config["mode"] : nil
+        slugify_cased = slugify_config.has_key?("cased") ? slugify_config["cased"] : false
+        return toFormat.sub(":author", Jekyll::Utils.slugify(author.to_s, mode:slugify_mode, cased:slugify_cased))
+      end
+
+    end
+
+  end
+end

data/lib/jekyll-auto-authors/version.rb

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

data/lib/jekyll-auto-authors.rb

@@ -0,0 +1,12 @@
+require "jekyll-auto-authors/version"
+require "jekyll-auto-authors/main"
+
+# Author pages generation logic.
+require "jekyll-auto-authors/utils"
+require "jekyll-auto-authors/defaults"
+require "jekyll-auto-authors/authorAutoPage"
+
+module Jekyll 
+  module AutoAuthors
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-auto-authors
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gourav Khunger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-03-24 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.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: jekyll-paginate-v2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: A plugin to seamlessly support multiple authors with paginated posts
+  inside a jekyll powered publication blog. Extends jekyll-paginate-v2 for Autopages
+  and Pagination.
+email:
+- gouravkhunger18@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- jekyll-auto-authors.gemspec
+- lib/jekyll-auto-authors.rb
+- lib/jekyll-auto-authors/authorAutoPage.rb
+- lib/jekyll-auto-authors/defaults.rb
+- lib/jekyll-auto-authors/main.rb
+- lib/jekyll-auto-authors/utils.rb
+- lib/jekyll-auto-authors/version.rb
+homepage: https://github.com/gouravkhunger/jekyll-auto-authors
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Seamless multiple authors support for jekyll powered publications
+test_files: []