jekyll-paginate 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c5fb560a34bf2fd26ddfca7dc2ae33c2d923426
+  data.tar.gz: 9a52441aaa8bd179c48930cb67cb7696ced64170
+SHA512:
+  metadata.gz: 94ef1f8b09e849fb5f1ca02bd22beca83b9e2bdf591c9efda28887ece8cc7333202fd2654987d67cc2f21fd896ffe4cd4625875fc549de524b32c241851f92fe
+  data.tar.gz: 1fb0f9a8f3fc038280b34fe69a4e468da5bbe5628314d12f96f53f47d1b11719c0b578633794dbb18bf7dbcfe52c3f3dbdf0181c3f353fb687918a8648ef7a0d

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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Parker Moore
+
+MIT License
+
+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,29 @@
+# Jekyll::Generators::Pagination
+
+Default pagination generator for Jekyll.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jekyll-paginate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jekyll-paginate
+
+## Usage
+
+Once the gem is installed on your system, Jekyll will auto-require it. Just set the following configuration
+
+## Contributing
+
+1. Fork it ( http://github.com/jekyll/jekyll-paginate/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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/jekyll-paginate.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jekyll-paginate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jekyll-paginate"
+  spec.version       = Jekyll::Paginate::VERSION
+  spec.authors       = ["Parker Moore"]
+  spec.email         = ["parkrmoore@gmail.com"]
+  spec.summary       = %q{Built-in Pagination Generator for Jekyll}
+  spec.homepage      = "https://github.com/jekyll/jekyll-paginate"
+  spec.license       = "MIT"
+
+  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", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/jekyll-paginate.rb

@@ -0,0 +1,8 @@
+require "jekyll-paginate/version"
+require "jekyll-paginate/pager"
+require "jekyll-paginate/pagination"
+
+module Jekyll
+  module Paginate
+  end
+end

data/lib/jekyll-paginate/pager.rb

@@ -0,0 +1,137 @@
+module Jekyll
+  module Paginate
+    class Pager
+      attr_reader :page, :per_page, :posts, :total_posts, :total_pages,
+        :previous_page, :previous_page_path, :next_page, :next_page_path
+
+      # 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_pages(all_posts, per_page)
+        (all_posts.size.to_f / per_page.to_i).ceil
+      end
+
+      # Determine if pagination is enabled the site.
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns true if pagination is enabled, false otherwise.
+      def self.pagination_enabled?(site)
+       !site.config['paginate'].nil? &&
+         site.pages.size > 0
+      end
+
+      # Static: Determine if a page is a possible candidate to be a template page.
+      #         Page's name must be `index.html` and exist in any of the directories
+      #         between the site source and `paginate_path`.
+      #
+      # config - the site configuration hash
+      # page   - the Jekyll::Page about which we're inquiring
+      #
+      # Returns true if the
+      def self.pagination_candidate?(config, page)
+        page_dir = File.dirname(File.expand_path(remove_leading_slash(page.path), config['source']))
+        paginate_path = remove_leading_slash(config['paginate_path'])
+        paginate_path = File.expand_path(paginate_path, config['source'])
+        page.name == 'index.html' &&
+          in_hierarchy(config['source'], page_dir, File.dirname(paginate_path))
+      end
+
+      # Determine if the subdirectories of the two paths are the same relative to source
+      #
+      # source        - the site source
+      # page_dir      - the directory of the Jekyll::Page
+      # paginate_path - the absolute paginate path (from root of FS)
+      #
+      # Returns whether the subdirectories are the same relative to source
+      def self.in_hierarchy(source, page_dir, paginate_path)
+        return false if paginate_path == File.dirname(paginate_path)
+        return false if paginate_path == Pathname.new(source).parent
+        page_dir == paginate_path ||
+          in_hierarchy(source, page_dir, File.dirname(paginate_path))
+      end
+
+      # Static: Return the pagination path of the page
+      #
+      # site     - the Jekyll::Site object
+      # num_page - the pagination page number
+      #
+      # Returns the pagination path as a string
+      def self.paginate_path(site, num_page)
+        return nil if num_page.nil?
+        return Generators::Pagination.first_page_url(site) if num_page <= 1
+        format = site.config['paginate_path']
+        format = format.sub(':num', num_page.to_s)
+        ensure_leading_slash(format)
+      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)
+        ensure_leading_slash(path)[1..-1]
+      end
+
+      # Initialize a new Pager.
+      #
+      # site     - the Jekyll::Site object
+      # page      - 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(site, page, all_posts, num_pages = nil)
+        @page = page
+        @per_page = site.config['paginate'].to_i
+        @total_pages = num_pages || Pager.calculate_pages(all_posts, @per_page)
+
+        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) >= all_posts.size ? all_posts.size : (init + @per_page - 1)
+
+        @total_posts = all_posts.size
+        @posts = all_posts[init..offset]
+        @previous_page = @page != 1 ? @page - 1 : nil
+        @previous_page_path = Pager.paginate_path(site, @previous_page)
+        @next_page = @page != @total_pages ? @page + 1 : nil
+        @next_page_path = Pager.paginate_path(site, @next_page)
+      end
+
+      # Convert this Pager's data to a Hash suitable for use by Liquid.
+      #
+      # Returns the Hash representation of this Pager.
+      def to_liquid
+        {
+          'page' => page,
+          'per_page' => per_page,
+          'posts' => posts,
+          'total_posts' => total_posts,
+          'total_pages' => total_pages,
+          'previous_page' => previous_page,
+          'previous_page_path' => previous_page_path,
+          'next_page' => next_page,
+          'next_page_path' => next_page_path
+        }
+      end
+
+    end
+  end
+end

data/lib/jekyll-paginate/pagination.rb

@@ -0,0 +1,85 @@
+module Jekyll
+  module Generators
+    class Pagination < 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.
+      #
+      # site - The Site.
+      #
+      # Returns nothing.
+      def generate(site)
+        if Pager.pagination_enabled?(site)
+          if template = template_page(site)
+            paginate(site, template)
+          else
+            Jekyll.logger.warn "Pagination:", "Pagination is enabled, but I couldn't find " +
+            "an index.html page to use as the pagination template. Skipping pagination."
+          end
+        end
+      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.
+      # page - The index.html Page that requires pagination.
+      #
+      # {"paginator" => { "page" => <Number>,
+      #                   "per_page" => <Number>,
+      #                   "posts" => [<Post>],
+      #                   "total_posts" => <Number>,
+      #                   "total_pages" => <Number>,
+      #                   "previous_page" => <Number>,
+      #                   "next_page" => <Number> }}
+      def paginate(site, page)
+        all_posts = site.site_payload['site']['posts']
+        pages = Pager.calculate_pages(all_posts, site.config['paginate'].to_i)
+        (1..pages).each do |num_page|
+          pager = Pager.new(site, num_page, all_posts, pages)
+          if num_page > 1
+            newpage = Page.new(site, site.source, page.dir, page.name)
+            newpage.pager = pager
+            newpage.dir = Pager.paginate_path(site, num_page)
+            site.pages << newpage
+          else
+            page.pager = pager
+          end
+        end
+      end
+
+      # Static: Fetch the URL of the template page. Used to determine the
+      #         path to the first pager in the series.
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns the url of the template page
+      def self.first_page_url(site)
+        if page = Pagination.new.template_page(site)
+          page.url
+        else
+          nil
+        end
+      end
+
+      # Public: Find the Jekyll::Page which will act as the pager template
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns the Jekyll::Page which will act as the pager template
+      def template_page(site)
+        site.pages.dup.select do |page|
+          Pager.pagination_candidate?(site.config, page)
+        end.sort do |one, two|
+          two.path.size <=> one.path.size
+        end.first
+      end
+
+    end
+  end
+end

data/lib/jekyll-paginate/version.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  module Paginate
+    VERSION = "1.0.0.rc1"
+  end
+end

data/script/bootstrap

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle install

data/script/cibuild

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exec rspec

data/spec/pager_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe(Jekyll::Paginate::Pager) do
+
+  it "calculate number of pages" do
+    expect(described_class.calculate_pages([], '2')).to eql(0)
+    expect(described_class.calculate_pages([1], '2')).to eql(1)
+    expect(described_class.calculate_pages([1,2], '2')).to eql(1)
+    expect(described_class.calculate_pages([1,2,3], '2')).to eql(2)
+    expect(described_class.calculate_pages([1,2,3,4], '2')).to eql(2)
+    expect(described_class.calculate_pages([1,2,3,4,5], '2')).to eql(3)
+  end
+
+  context "with the default paginate_path" do
+    let(:site) { build_site }
+
+    it "determines the correct pagination path for each page" do
+      expect(described_class.paginate_path(site, 1)).to eql("/index.html")
+      expect(described_class.paginate_path(site, 2)).to eql("/page2")
+    end
+  end
+
+  context "with paginate_path set to a subdirectory with no index.html" do
+    let(:site) { build_site({'paginate_path' => '/blog/page-:num'}) }
+
+    it "determines the correct pagination path for each page" do
+      expect(described_class.paginate_path(site, 1)).to eql("/index.html")
+      expect(described_class.paginate_path(site, 2)).to eql("/blog/page-2")
+    end
+  end
+
+  context "with paginate_path set to a subdirectory with no index.html with num pages being in subdirectories" do
+    let(:site) { build_site({'paginate_path' => '/blog/page/:num'}) }
+
+    it "determines the correct pagination path for each page" do
+      expect(described_class.paginate_path(site, 1)).to eql("/index.html")
+      expect(described_class.paginate_path(site, 2)).to eql("/blog/page/2")
+    end
+  end
+
+  context "with paginate_path set to a subdirectory wherein an index.html exists" do
+    let(:site) { build_site({'paginate_path' => '/contacts/page:num'}) }
+
+    it "determines the correct pagination path for each page" do
+      expect(described_class.paginate_path(site, 1)).to eql("/contacts/index.html")
+      expect(described_class.paginate_path(site, 2)).to eql("/contacts/page2")
+    end
+  end
+
+  context "with paginate_path set to a subdir wherein an index.html exists with pages in subdirs" do
+    let(:site) { build_site({'paginate_path' => '/contacts/page/:num'}) }
+
+    it "determines the correct pagination path for each page" do
+      expect(described_class.paginate_path(site, 1)).to eql("/contacts/index.html")
+      expect(described_class.paginate_path(site, 2)).to eql("/contacts/page/2")
+    end
+  end
+
+  context "pagination disabled" do
+    let(:site) { build_site('paginate' => nil) }
+
+    it "report that pagination is disabled" do
+      expect(described_class.pagination_enabled?(site)).to be_false
+    end
+  end
+
+  context "pagination enabled for 2" do
+    let(:site)  { build_site('paginate' => 2) }
+    let(:posts) { site.posts }
+
+    it "report that pagination is enabled" do
+      expect(described_class.pagination_enabled?(site)).to be_true
+    end
+
+    context "with 4 posts" do
+      let(:posts) { site.posts[1..4] }
+
+      it "create first pager" do
+        pager = described_class.new(site, 1, posts)
+        expect(pager.posts.size).to eql(2)
+        expect(pager.total_pages).to eql(2)
+        expect(pager.previous_page).to be_nil
+        expect(pager.next_page).to eql(2)
+      end
+
+      it "create second pager" do
+        pager = described_class.new(site, 2, posts)
+        expect(pager.posts.size).to eql(2)
+        expect(pager.total_pages).to eql(2)
+        expect(pager.previous_page).to eql(1)
+        expect(pager.next_page).to be_nil
+      end
+
+      it "not create third pager" do
+        expect { described_class.new(site, 3, posts) }.to raise_error
+      end
+
+    end
+
+    context "with 5 posts" do
+      let(:posts) { site.posts[1..5] }
+
+      it "create first pager" do
+        pager = described_class.new(site, 1, posts)
+        expect(pager.posts.size).to eql(2)
+        expect(pager.total_pages).to eql(3)
+        expect(pager.previous_page).to be_nil
+        expect(pager.next_page).to eql(2)
+      end
+
+      it "create second pager" do
+        pager = described_class.new(site, 2, posts)
+        expect(pager.posts.size).to eql(2)
+        expect(pager.total_pages).to eql(3)
+        expect(pager.previous_page).to eql(1)
+        expect(pager.next_page).to eql(3)
+      end
+
+      it "create third pager" do
+        pager = described_class.new(site, 3, posts)
+        expect(pager.posts.size).to eql(1)
+        expect(pager.total_pages).to eql(3)
+        expect(pager.previous_page).to eql(2)
+        expect(pager.next_page).to be_nil
+      end
+
+      it "not create fourth pager" do
+        expect { described_class.new(site, 4, posts) }.to raise_error(RuntimeError)
+      end
+
+    end
+  end
+
+end

data/spec/source/contacts/index.html

@@ -0,0 +1,2 @@
+---
+---

data/spec/source/index.html

@@ -0,0 +1,2 @@
+---
+---

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'jekyll'
+require File.expand_path("../lib/jekyll-paginate", File.dirname(__FILE__))
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+
+  def test_dir(*subdirs)
+    File.join(File.dirname(__FILE__), *subdirs)
+  end
+
+  def dest_dir(*subdirs)
+    test_dir('dest', *subdirs)
+  end
+
+  def source_dir(*subdirs)
+    test_dir('source', *subdirs)
+  end
+
+  def build_configs(overrides, base_hash = Jekyll::Configuration::DEFAULTS)
+    Jekyll::Utils.deep_merge_hashes(base_hash, overrides)
+  end
+
+  def site_configuration(overrides = {})
+    build_configs({
+      "source"      => source_dir,
+      "destination" => dest_dir
+    }, build_configs(overrides))
+  end
+
+  def build_site(config = {})
+    site = Jekyll::Site.new(site_configuration(
+      {"paginate" => 1}.merge(config)
+    ))
+    site.process
+    site
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-paginate
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Parker Moore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- parkrmoore@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jekyll-paginate.gemspec
+- lib/jekyll-paginate.rb
+- lib/jekyll-paginate/pager.rb
+- lib/jekyll-paginate/pagination.rb
+- lib/jekyll-paginate/version.rb
+- script/bootstrap
+- script/cibuild
+- spec/pager_spec.rb
+- spec/pagination_spec.rb
+- spec/source/_posts/2014-05-20-blah.html
+- spec/source/_posts/2014-05-21-bleh.html
+- spec/source/_posts/2014-05-22-humor.html
+- spec/source/_posts/2014-05-23-hey-there.html
+- spec/source/_posts/2014-05-24-whateva.html
+- spec/source/_posts/2014-05-25-oh-yes.html
+- spec/source/contacts/index.html
+- spec/source/index.html
+- spec/spec_helper.rb
+homepage: https://github.com/jekyll/jekyll-paginate
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Built-in Pagination Generator for Jekyll
+test_files:
+- spec/pager_spec.rb
+- spec/pagination_spec.rb
+- spec/source/_posts/2014-05-20-blah.html
+- spec/source/_posts/2014-05-21-bleh.html
+- spec/source/_posts/2014-05-22-humor.html
+- spec/source/_posts/2014-05-23-hey-there.html
+- spec/source/_posts/2014-05-24-whateva.html
+- spec/source/_posts/2014-05-25-oh-yes.html
+- spec/source/contacts/index.html
+- spec/source/index.html
+- spec/spec_helper.rb