Nanoc-а тред

compile '/**/*.html' do
  layout '/default.*'
end

<% @items.find_all('/blog/*').each do |item| %>
<%= item[:title] %>
<% end %>

$ nanoc create sample && cd sample

$ mkdir -p content/kittens
$ for i in {1..42}; do
cat > content/kittens/kitten-$(printf "%02d" $i).html <<CONTENT
---
title: "Kitten #$i"
---
<p>My favourite kitten #${i}:</p>
<img src="http://placekitten.com/450/450?image=$i" />
CONTENT
done

class Pagination
  attr_reader :page_count
  attr_reader :per_page
  attr_reader :items

  DSL_METHODS = %i(layout slug index)
  DSL_METHODS.each do |name|
    define_method(name) do |value = nil|
      if value.nil?
        instance_variable_get("@#{name}")
      else
        instance_variable_set("@#{name}", value)
      end
    end
  end

  def initialize(items, per_page)
    @items = items
    @per_page = per_page
    @page_count = (items.size / per_page.to_f).ceil
  end
end

class Page
  attr_reader :page_count
  attr_reader :per_page
  attr_reader :number
  attr_reader :items

  attr_accessor :previous
  attr_accessor :next
  attr_accessor :item

  def initialize(items, number, per_page, page_count)
    @items = items
    @number = number
    @per_page = per_page
    @page_count = page_count
  end
end

class Nanoc::RuleDSL::CompilerDSL
  def pagination_for(pattern, per_page: 10, &block)
    raise 'block not given' unless block_given?

    preprocess do
      items = @items.find_all(pattern)
      items = items.sort_by { |i| i[:filename] }
      pagination = Pagination.new(items, per_page)

      if block.arity.zero?
        pagination.instance_eval(&block)
      else
        yield pagination
      end

      Pagination::DSL_METHODS.each do |name|
        raise "#{name} not defined" if pagination.public_send(name).nil?
      end

      layout = @layouts[pagination.layout]
      raise "layout not found: #{pagination.layout}" unless layout
      layout = layout.raw_content

      slug = pagination.slug

      item_slices = pagination.items.each_slice(pagination.per_page)
      pages = item_slices.each_with_index.map do |page_items, index|
        number = index + 1

        page = Page.new(page_items, number, per_page, pagination.page_count)

        attrs = {
          page: page
        }
        identifier = format(slug, page: number)
        @items.create(layout, attrs, identifier)

        page.item = @items[identifier]

        page
      end

      pages.each_cons(2) do |(previous_page, current_page)|
        current_page.previous = previous_page
        previous_page.next = current_page
      end

      index_page = pages.first
      attrs = {
        page: index_page
      }
      @items.create(layout, attrs, pagination.index) if index_page
    end
  end
end

def paginate
  raise 'block not given' unless block_given?
  raise 'nothing to paginate' unless @item[:page]

  yield @item[:page]
end

include Nanoc::Helpers::LinkTo

#!/usr/bin/env ruby

pagination_for '/kittens/kitten-*.html', per_page: 5 do
  layout '/kittens.html'
  index '/kittens/index.html'
  slug '/kittens/page/%{page}.html'
end

compile '/kittens/**/*.html' do
  layout '/default.html'
  filter :erb
  write item.identifier.to_s
end

compile '/**/*' do
  write item.identifier.to_s
end

layout '/**/*', :erb

<h1>My favourite kittens</h1>

<% paginate do |page| %>
  <ul>
    <% page.items.each do |kitten| %>
      <li>
        <%= link_to(kitten[:title], kitten.identifier.to_s) %>
      </li>
    <% end %>
  </ul>

  <nav>
    Displaying page <%= page.number %> of <%= page.page_count %>

    <ul>
      <% if page.previous %>
        <li><%= link_to('Previous', page.previous.item.identifier.to_s) %>
      <% end %>
      <% if page.next %>
        <li><%= link_to('Next', page.next.item.identifier.to_s) %>
      <% end %>
    </ul>
  </nav>
<% end %>