jekyll-printing-press 1.0.0rc1

data/lib/jekyll/pandoc/printing.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'pdf/info'
+require_relative 'utils'
+
+module Jekyll
+  module Pandoc
+    # Mixin to take a single page PDF and generate a ready for print
+    # PDF.
+    #
+    # The implementation uses a Liquid template written in TeX to
+    # import the original PDF and generate a new PDF with the printing
+    # layout.
+    module Printing
+      # How many pages fit per sheet.  To obtain them divide the sheet
+      # size value by the page size value.  An A0 sheet fits 128 A7 pages.
+      #
+      # @return [Hash]
+      SHEET_SIZES = {
+        a7: 2,
+        a6: 4,
+        a5: 8,
+        a4: 16,
+        a3: 32,
+        a2: 64,
+        a1: 128,
+        a0: 256
+      }.freeze
+
+      # Which sheet sizes are landscaped
+      #
+      # @return [Array]
+      LANDSCAPE = [2, 8, 32, 128].freeze
+
+      private
+
+      # Options for the template
+      #
+      # @return [Array]
+      def options
+        @options ||= [('landscape' if landscape?)].compact
+      end
+
+      # LaTeX template for processing a PDF and rearranging its pages
+      #
+      # @return [Liquid::Template]
+      def template
+        @template ||= Liquid::Template.parse(File.read(File.join(File.dirname(__FILE__), 'printing.latex.liquid')))
+      end
+
+      # Generates an array of pages in the order they need to be printed.
+      # This depends on the printer implementation.
+      #
+      # @return [Array]
+      def pages
+        raise NotImplementError
+      end
+
+      # Sheet size.  The sheet is the paper where the pages are printed
+      # on.
+      #
+      # @return [Symbol]
+      def sheetsize
+        @sheetsize ||= site.config.dig('pandoc', 'printing', 'sheetsize').to_sym.tap do |x|
+          raise NoMethodError unless SHEET_SIZES.key? x
+        end
+      rescue NoMethodError
+        Jekyll.logger.warn "Sheetsize is missing or incorrect, please add one of #{SHEET_SIZES.keys.join(', ')} to _config.yml"
+        raise ArgumentError, 'Please configure the jekyll-pandoc-multiple-formats plugin'
+      end
+
+      # Page size is the same as papersize
+      #
+      # @return [Symbol]
+      def pagesize
+        @pagesize ||= site.config['pandoc'].papersize.tap do |x|
+          raise NoMethodError unless SHEET_SIZES.key? x
+        end
+      rescue NoMethodError
+        Jekyll.logger.warn "Papersize is missing or incorrect, please add one of #{SHEET_SIZES.keys.join(', ')} to PDF format in _config.yml"
+        raise ArgumentError, 'Please configure the jekyll-pandoc-multiple-formats plugin'
+      end
+
+      # Represents a blank page
+      #
+      # @return [String]
+      def blank_page
+        @blank_page ||= '{}'
+      end
+
+      # Page count in the source PDF
+      #
+      # PDFInfo requires `pdfinfo` from Poppler installed.
+      #
+      # XXX: It may be possible to extract the metadata just by
+      # `#binread`ing the file, but apparently PDF has many ways to
+      # inform the page count, so we're adding this dependency for
+      # simplicity.
+      #
+      # @return [Integer]
+      def page_count
+        @page_count ||= PDF::Info.new(document.source_document.tempfile.path).metadata[:page_count]
+      end
+
+      # Pages per sheet
+      #
+      # @return [Integer]
+      def nup
+        @nup ||= SHEET_SIZES[sheetsize] / SHEET_SIZES[pagesize]
+      end
+
+      # Information for rendering the template
+      #
+      # @return [Hash]
+      def template_payload
+        @template_payload ||=
+          {
+            'nup' => nup,
+            'sheetsize' => "#{sheetsize}paper",
+            'options' => options,
+            'path' => document.source_document.tempfile.path,
+            'pages' => pages
+          }
+      end
+
+      # Renders the template.  We're following Jekyll's process where
+      # templates are rendered and written in different steps.
+      #
+      # @return [String]
+      def render_template
+        template.render(**template_payload)
+      end
+
+      # Generates a new PDF and writes it into the site.
+      #
+      # @return [String] empty output
+      def convert(_)
+        Dir.mktmpdir do |dir|
+          Dir.chdir dir do
+            Open3.popen2e(Utils.tectonic, '-') do |stdin, stdout, thread|
+              stdin.puts render_template
+              stdin.close
+              stderr = stdout.read
+
+              # Wait for the process to finish and raise an error if it fails
+              unless thread.value.success?
+                raise StandardError, "I couldn't generate #{document.relative_path}, the process said: #{stderr}"
+              end
+
+              # Copy the contents to the tempfile
+              IO.copy_stream(File.open('texput.pdf'), document.tempfile.path)
+            end
+          end
+        end
+
+        ''
+      end
+
+      # Detect if sheet should be printed in landscape mode.
+      #
+      # @return [Boolean]
+      def landscape?
+        LANDSCAPE.include? nup
+      end
+    end
+  end
+end

data/lib/jekyll/pandoc/renderer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'paru_helper'
+require_relative 'utils'
+
+module Jekyll
+  module Pandoc
+    # Renderer for Pandoc formats.  Contrary to Jekyll's workflow, the
+    # renderer doesn't call a {Jekyll::Converter}, because they convert
+    # based on origin format and not destination format.
+    class Renderer < Jekyll::Renderer
+      # Converts document using pandoc.  Pandoc needs the document
+      # content, maybe already rendered with Liquid, and the document
+      # metadata.
+      #
+      # For binary formats, the conversion string will be empty, and we
+      # write the output file on a temporary file that is later copied
+      # to the destination by {Jekyll::Pandoc::Document#write}.
+      #
+      # @param content [String]
+      # @return [String] empty string when binary file
+      def convert(content)
+        output = super
+        type = document.type
+        extra = {}
+        extra[:output] = document.tempfile.path if document.binary?
+
+        content = <<~EOD
+          #{Utils.sanitize_data(document.data).to_yaml}
+          ---
+
+          #{output}
+        EOD
+
+        File.open(File.join('/tmp', document.relative_path), 'w') do |f|
+          f.write content
+        end
+
+        ParuHelper.from(from: 'markdown', to: type, **site.config['pandoc'].options[type], **extra) << content
+      end
+
+      # Don't convert Markdown to HTML, but do convert everything else
+      #
+      # @return [array]
+      def converters
+        @converters ||= super.reject do |c|
+          c.instance_of? Jekyll::Converters::Markdown
+        end
+      end
+
+      # Output extension
+      #
+      # @return [String]
+      def output_ext
+        @output_ext ||= ".#{document.type}"
+      end
+
+      # Do nothing
+      def assign_pages!; end
+    end
+  end
+end

data/lib/jekyll/pandoc/renderers/binder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../renderer'
+require_relative '../printing'
+
+module Jekyll
+  module Pandoc
+    module Renderers
+      # Applies binder imposition to a PDF document
+      class Binder < Jekyll::Pandoc::Renderer
+        include Jekyll::Pandoc::Printing
+
+        # @return [String]
+        def output_ext
+          @output_ext ||= '-bound.pdf'
+        end
+
+        private
+
+        # Generates page order for binding, taking into account how many
+        # pages fit per sheet.
+        #
+        # @return [Array]
+        def pages
+          @pages ||= (1..page_count).map do |page|
+            [page] * nup
+          end.flatten
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/pandoc/renderers/imposition.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../renderer'
+require_relative '../printing'
+
+module Jekyll
+  module Pandoc
+    module Renderers
+      # Applies imposition to a PDF document
+      class Imposition < Jekyll::Pandoc::Renderer
+        include Jekyll::Pandoc::Printing
+
+        # @return [String]
+        def output_ext
+          @output_ext ||= '-imposed.pdf'
+        end
+
+        private
+
+        # Pages rounded up to the nearest modulo of 4
+        #
+        # @return [Integer]
+        def signed_pages
+          @signed_pages ||= (page_count + 3) / 4 * 4
+        end
+
+        # The signature is the amount of pages per fold, so it needs to
+        # be a modulo of 4.
+        #
+        # Default is {#page_count} rounded to the next modulo of 4.
+        #
+        # @return [Integer]
+        def signature
+          @signature ||= (site.config.dig('pandoc', 'printing', 'signature') || signed_pages).tap do |s|
+            raise ArgumentError, 'Signature needs to be modulo of 4' unless (s % 4).zero?
+          end
+        end
+
+        # Pages that are empty.  At most you'll have 3 empty pages.
+        #
+        # @return [Integer]
+        def blank_pages
+          @blank_pages ||= signed_pages - page_count
+        end
+
+        # Generates page order for imposition, taking into account how
+        # many pages fit per sheet.
+        #
+        # @return [Array]
+        def pages
+          # Generate a list of page numbers and pad to signed pages with
+          # blank pages.
+          padded = (1..page_count).to_a + Array.new(blank_pages, blank_page)
+
+          # Each fold is the size of the signature
+          padded.each_slice(signature).map do |fold|
+            # And is split in half
+            first, last = fold.each_slice(fold.size / 2).to_a
+
+            # Add padding
+            last << nil
+            # Reverse and split in pairs
+            last = last.reverse.each_slice(2)
+            # Just split in pairs
+            first = first.each_slice(2)
+
+            # Apply page order, for instance a sheet would have pages
+            # 20, 1, 2, and 19, and then apply pages on sheet depending
+            # on its N-up number.
+            #
+            # If nup is greater than 2, instead of making this algorithm
+            # more complex, we just print nup/2 copies of the PDF.  So
+            # you have more to share!
+            last.zip(first.to_a).flatten.compact.each_slice(2).map do |pair|
+              pair * (nup / 2)
+            end
+          end.flatten
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/pandoc/utils.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Jekyll
+  module Pandoc
+    # Finds external commands
+    module Utils
+      extend self
+
+      # Remove these keys from {#data}
+      #
+      # @return [Array]
+      EXCLUDED_DATA = %w[excerpt permalink].freeze
+
+      # Remove and transform values for safe YAML dumping.
+      #
+      # Copied almost verbatim from jekyll-linked-posts
+      #
+      # @return [Hash]
+      def sanitize_data(data)
+        data.reject do |k, _|
+          EXCLUDED_DATA.include? k
+        end.transform_values do |value|
+          case value
+          when Jekyll::Document
+            value.data['uuid']
+          when Jekyll::Convertible
+            value.data['uuid']
+          when Set
+            value.map do |v|
+              v.respond_to?(:data) ? v.data['uuid'] : v
+            end
+          when Array
+            value.map do |v|
+              v.respond_to?(:data) ? v.data['uuid'] : v
+            end
+          when Hash
+            value.transform_values do |v|
+              v.respond_to?(:data) ? v.data['uuid'] : v
+            end
+          else
+            value
+          end
+        end
+      end
+
+      # Yes, we do respond to any method called.
+      def respond_to_missing?(_, _)
+        true
+      end
+
+      # Allow to call #program_name and #program_name? instead of calling
+      # `which` everytime.
+      def method_missing(name, *_args)
+        n = name.to_s.sub(/\?\z/, '').to_sym
+
+        define_method(n) do
+          which n.to_s
+        end
+
+        define_method(:"#{n}?") do
+          !which(n.to_s).empty?
+        rescue ArgumentError
+          false
+        end
+
+        public_send name
+      end
+
+      # Find a program in PATH by name or throw an error
+      #
+      # @param util [String] Program name
+      # @return [String] Program path
+      def which(util)
+        @which_cache ||= {}
+        @which_cache[util] ||=
+          begin
+            result = nil
+
+            Open3.popen2('which', util) do |stdin, stdout, thread|
+              stdin.close
+              result = stdout.read.strip
+
+              unless thread.value.success?
+                raise ArgumentError, "Couldn't find #{util} on your PATH, maybe you need to install it?"
+              end
+            end
+
+            result
+          end
+      end
+    end
+  end
+end

data/lib/jekyll-pandoc-multiple-formats.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'jekyll/pandoc/configuration'
+require_relative 'jekyll/converters/markdown/pandoc'
+require_relative 'jekyll/pandoc/generators/posts'
+require_relative 'jekyll/pandoc/generators/category'
+require_relative 'jekyll/pandoc/generators/site'
+require_relative 'jekyll/pandoc/generators/imposition'
+require_relative 'jekyll/pandoc/generators/binder'
+
+# We modify the configuration post read, and not after init, because
+# Jekyll resets twice and any modification to config will invalidate the
+# cache.
+Jekyll::Hooks.register :site, :post_read, priority: :high do |site|
+  site.config['pandoc'] = Jekyll::Pandoc::Configuration.new(site).tap(&:process)
+end