jekyll-printing-press 1.0.0rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a3b26467e087e03edaf35e1dc1ad9d6308db3cf0863b50e85cd567df62377ab
+  data.tar.gz: 6f40f3d1f0ff47d26352d7a22a2aa306caffeab3e2a58124af6b8431f9bbf12c
+SHA512:
+  metadata.gz: cf9d1904526652fec66d92ba883d37f767490a68830e5704644167770d4c68317d591a91f38607ce66919717730fbd57d801469ebc20f0409d73ea9de420e459
+  data.tar.gz: a6f78d032bcae07dc0e4635ce9f0c0d65c56a7816ee2ebc6dabf30dc5d9cb63d7647f4c8c71fdc2eacd702836f64022fec854ce7259d70ccc5870242a9eb49b8

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012-2021 fauno <fauno@endefensadelsl.org>
+              See CONTRIBUTORS.md
+
+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,222 @@
+# Another pandoc plugin for jekyll
+
+This jekyll plugin was inspired by [jekyll-pandoc-plugin][1] but it was changed
+to generate multiple outputs, rather than just using pandoc to generate jekyll
+html posts. Besides, it doesn't require the 'pandoc-ruby' gem.
+
+It's used on [En Defensa del Software Libre][0]. Please check [our
+repo](https://github.com/edsl/endefensadelsl.org) if you like to see how
+it works in production.
+
+[0]: http://endefensadelsl.org
+[1]: https://github.com/dsanson/jekyll-pandoc-plugin
+
+
+## What does it do
+
+It replaces the html generation for pandoc. This means you will have
+support for pandoc's markdown extensions, like ~strikethrough~ and
+[@cite], tables and [a lot more stuff](http://pandoc.org/README.html).
+
+It'll also generate the post in other formats you like, so your
+blog can be made available in different formats at the same time. Epub
+for ebook readers, mediawiki for copy&paste to wikis, etc.
+
+If instructed, this plugin will also generate pdfs in ready for print
+format.
+
+
+## Configuration
+
+Add to `_config.yml`:
+
+```yaml
+
+markdown: pandoc
+pandoc:
+    skip:
+      full: false
+      posts: false
+      categories: false
+    bundle_permalink: ':output_ext/:slug.:output_ext'
+    papersize: 'a5paper'
+    sheetsize: 'a4paper'
+    imposition: true
+    binder: true
+    covers_dir: assets/covers
+    signature: 20
+    full_file: true
+
+    flags: '--smart'
+    site_flags: '--toc'
+    outputs:
+      latex:
+      pdf: '--latex-engine=xelatex'
+      epub: '--epub-chapter-level=2'
+    lang:
+      ar:
+        all: '-V mainfont="Amiri"'
+        pdf: '--include-in-header=_layouts/rtl.tex'
+```
+
+* `markdown: pandoc` will instruct jekyll to use the pandoc html
+  converter.
+
+* `skip` allows you to skip the other formats generation and proceed
+  with the regular jekyll site build.  You can skip some of the
+  generation process or all of it.  Older versions of this plugin
+  required `true` or `false` to skip the process altogether.
+
+* `full_flags` if `full_file` is defined, these flags are used on it.
+  By default are set to `--top-level-division=part` so each category is
+  a different book part.
+
+* `site_flags` are flags applied to the html generation
+
+* `flags` is a string with the flags you will normally pass to `pandoc` on cli.
+  It's used on all output types.
+
+* `outputs` is a hash of output formats (even markdown!). You can add
+  output-specific flags.
+
+* `imposition` creates ready to print PDFs if you're creating PDF
+  output.
+
+* `binder` creates ready to print PDFs 
+
+* `bundle_permalink` is the path of the bundled articles
+
+* `papersize` is the page size for PDF.  You can also use this option on
+  the front matter.
+
+* `sheetsize` is the page size for ready the print PDF.  You can also
+  use this option on the front matter.
+
+* `covers_dir` the directory where covers are stored.  If you have a
+  `lang` defined, it will append the language to the `covers_dir` when
+  looking for a category/full site cover, so you can have localized
+  covers.
+
+* `signature` is the amount of pages per fold on the imposition version.
+  Specify `0` for a single fold of all the pages.  You can also use this
+  option on the front matter.
+
+* `full_file` generates a single file containing all articles, sectioned
+  by their main category (the first one defined if many).
+
+* `lang` is a hash where you can define per-language flags.  If you have
+  a `lang` attribute in your site config, this plugin will add the
+  `-V lang=XX` flag and any language-specific flag you want.  You can
+  define language flags for `all` formats or for specific formats.
+
+**IMPORTANT**: As of version 0.1.0 the syntax of the config changed.
+Please upgrade your `_config.yml` accordingly.
+
+
+## Front Matter
+
+### Covers
+
+Support for epub covers has been added.  You can add the path to
+a cover on the front matter of the article to have pandoc add a cover
+image on the epub result.
+
+    ---
+    cover: images/awesome.png
+    ---
+
+For categories or posts without a cover specified, the plugin looks for
+a PNG file inside the `covers_dir` whose file name will be the
+category/post slug.
+
+Since 0.2.0, there's also support for PDF covers.  If you have a PNG
+cover, it will get converted to PDF.  You can also provide a PDF cover
+as long as it's the same file name as the PNG cover.
+
+* Category cover: `assets/covers/the_category_slug.png`
+* PDF cover: `assets/covers/the_slug.pdf`
+
+### Paper sizes
+
+For PDFs, each article can have a `papersize` and a `sheetsize`.  The
+`papersize` indicates the page size, and the `sheetsize` indicates the
+pages per fold size.
+
+Only A* sizes from A7 to A0 are supported for now.
+
+    ---
+    papersize: a5paper
+    sheesize: a4paper
+    ---
+
+This example will generate a 2 pages per A4 sheet.
+
+### Bundled articles
+
+If articles share a category, the generator will create a PDF book
+including all of them.  The name of the category will become the title
+of the book.
+
+    ---
+    category: [ 'En Defensa del Software Libre #0' ]
+    ---
+
+The papersize will be the `papersize` of the first article found or the
+default papersize on the `_config.yml` file.  Same applies for
+`sheetsize`.
+
+NOTE: Authorship will be set to empty.  This could change in the future.
+
+## Bibliography
+
+If you have bibliography, pandoc recommends leaving an empty
+section at the end of the document if you want to have a separate
+section for it. For bundled articles, this plugin will remove the extra
+sections and create one for everything at the end.
+
+    # Bibliography
+    
+    <EOF>
+
+You can also use the underlined version of the section title (aka
+`settext style` vs `atx style`).
+
+
+## Layout
+
+Add this liquid snippet on your `_layout/post.html` to generate links to the
+other available formats from the post itself:
+
+      <ul>
+        {% for format in site.pandoc.outputs %}
+        {% capture extension %}{{ format | first }}{% endcapture %}
+        <li>
+          <a href="{{ page.url | remove:'.html' }}.{{ extension }}">
+            {{ extension }}
+          </a>
+        </li>
+        {% endfor %}
+      </ul>
+
+## How to install
+
+Add this snippet to your `_config.yml` on jekyll 1.3
+
+    gems: [ 'jekyll-pandoc-multiple-formats' ]
+
+Alternative, see
+[here](https://github.com/fauno/jekyll-pandoc-multiple-formats/issues/7).
+
+
+## How to run
+
+Execute `jekyll build` normally :D
+
+## Tectonic
+
+If you want to use Tectonic, make sure it's installed into
+`/usr/bin/tectonic` (or symlink it).  It will be used instead of rtex
+for imposition and adding covers.
+
+It's specially useful if you're using unicode characters in your file
+names.

data/lib/jekyll/converters/markdown/pandoc.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'jekyll/pandoc/paru_helper'
+require 'jekyll/pandoc/utils'
+
+module Jekyll
+  module Converters
+    class Markdown
+      # Converts markdown content using Pandoc.
+      #
+      # A previous iteration of this converter monkeypatched Jekyll (10
+      # years ago!).  Now we just use the method Jekyll provides which
+      # also provides caching.
+      #
+      # @see Jekyll::Converters::Markdown
+      # @see Jekyll::Converters::Markdown::KramdownParser
+      class Pandoc
+        # @return [Jekyll::Configuration]
+        attr_reader :config
+
+        # @param config [Jekyll::Configuration]
+        def initialize(config)
+          @config = config
+        end
+
+        # Convert the content into HTML
+        #
+        # @param content [String] Markdown
+        # @return [String] HTML
+        def convert(content)
+          parser << content
+        end
+
+        private
+
+        # Generates a parser from config
+        #
+        # @return [Paru::Pandoc]
+        def parser
+          @parser ||= Jekyll::Pandoc::ParuHelper.from(from: 'markdown+smart', to: 'html5',
+                                                      metadata: 'title=Jekyll',
+                                                      **config['pandoc'].options[:html5])
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/pandoc/configuration.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'jekyll/utils'
+
+module Jekyll
+  module Pandoc
+    # Processes Pandoc configuration by merging common, per format and
+    # current locale options.
+    #
+    # There's no default configuration.
+    class Configuration
+      extend Forwardable
+
+      SPECIAL_OPTIONS = %w[common locales].freeze
+
+      # Jekyll site
+      #
+      # @return [Jekyll::Site]
+      attr_reader :site
+
+      # Processed options
+      #
+      # @return [Hash]
+      attr_reader :options
+
+      # Delegate key accessors to config
+      def_delegators :config, :[], :dig
+
+      # @param site [Jekyll::Site]
+      def initialize(site)
+        @site = site
+        @options = {}
+      end
+
+      # Configuration from site
+      #
+      # @return [Hash]
+      def config
+        @config ||= site.config['pandoc'] || {}
+      end
+
+      # Current locale.  If you're using jekyll-locales, the site will
+      # be built once per locale, so the locale will be configured.
+      #
+      # @return [String,nil]
+      def current_locale
+        @current_locale ||= site.config['lang'] || site.config['locale']
+      end
+
+      # Available formats
+      #
+      # @return [Array]
+      def available_formats
+        @available_formats ||= ((config['options']&.keys || []) - SPECIAL_OPTIONS).map(&:to_sym).freeze
+      end
+
+      # Find PDF papersize
+      #
+      # @return [Symbol]
+      def papersize
+        @papersize ||= options.dig(:pdf, :variable).find do |v|
+          v.start_with? 'papersize='
+        end&.split('=', 2)&.last&.to_sym
+      end
+
+      # Merge all options and remove the ones disabled
+      #
+      # TODO: Process common first so it's not done for every format.
+      #
+      # @return [nil]
+      def process
+        return unless options.empty?
+
+        available_formats.each do |format|
+          options[format] =
+            paru_options(disable_options(reduce_options(format.to_s)))
+        end
+
+        nil
+      end
+
+      private
+
+      # @param format [String]
+      # @return [Hash]
+      def reduce_options(format)
+        [
+          config.dig('options', 'common'),
+          config.dig('options', 'locales', current_locale, 'common'),
+          config.dig('options', format),
+          config.dig('options', 'locales', current_locale)
+        ].compact.reduce do |config, next_config|
+          next_config = {} if next_config == true
+
+          Jekyll::Utils.deep_merge_hashes(config, next_config)
+        end
+      end
+
+      # Removes options with non truthy values
+      #
+      # @param options [Hash,nil]
+      # @return [Hash,nil]
+      def disable_options(options)
+        options&.select do |_, v|
+          v
+        end
+      end
+
+      # Convert options to Paru methods
+      #
+      # @param options [Hash,nil]
+      # @return [Hash,nil]
+      def paru_options(options)
+        options&.transform_keys do |k|
+          k.gsub('-', '_').to_sym
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/pandoc/document.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'jekyll/document'
+require_relative 'renderer'
+
+module Jekyll
+  module Pandoc
+    # Represents a single document.  Extends Jekyll::Document since it's
+    # the most complete class for managing documents.  Either
+    # Convertible or Page are too constrained and would require to
+    # rewrite a lot of code.
+    class Document < Jekyll::Document
+      # Binary formats are treated specially because Pandoc writes them
+      # to disk, unless we were to use - as output file and read
+      # everything into memory.
+      #
+      # @return [Array]
+      BINARY_FORMATS = %i[pdf epub epub3 fb2 docx odt].freeze
+
+      # Site
+      #
+      # @return [Jekyll::Site]
+      attr_reader :site
+
+      # Collection
+      #
+      # @return [Jekyll::Collection]
+      attr_reader :collection
+
+      # Source document
+      #
+      # @return [Jekyll::Document]
+      attr_reader :source_document
+
+      # Content
+      #
+      # @return [String]
+      attr_accessor :content
+
+      # Output.  Empty string if the file is in binary format
+      #
+      # @return [String]
+      attr_accessor :output
+
+      # @param path [String]
+      # @param relations [Hash]
+      def initialize(path, relations = {})
+        @source_document = relations[:source_document]
+        super
+      end
+
+      # Remove collection directory too so Jekyll doesn't confuse it
+      # with a category
+      #
+      # @return [String]
+      def relative_path
+        @relative_path ||= super.sub(source_document.collection.relative_directory, '')
+      end
+
+      # Temporary file where Pandoc writes binary formats
+      #
+      # @return [Tempfile]
+      def tempfile
+        @tempfile ||= Tempfile.new([data['slug'], output_ext])
+      end
+
+      # The path where the renderer wrote the actual contents for binary
+      # files.
+      #
+      # @return [String]
+      def rendered_path
+        tempfile.path
+      end
+
+      # Clone data from the source document
+      #
+      # @return [Hash]
+      def data
+        @data ||= source_document.data.dup
+      end
+
+      # Do nothing
+      def merge_defaults; end
+
+      # Duplicate the content
+      #
+      # @return [nil]
+      def read_content(**)
+        self.content = source_document.content.dup
+
+        nil
+      end
+
+      # "Read" data and adds itself to the source document data.
+      #
+      # @return [nil]
+      def read_post_data
+        # Assign a new UUIDv4 if the source document has one.
+        #
+        # TODO: How to assign the same UUID to every document?
+        if data.key? 'uuid'
+          require 'securerandom'
+          data['uuid'] = SecureRandom.uuid
+        end
+
+        data['binary'] = binary?
+
+        source_document.data['formats'] ||= []
+        source_document.data['formats']  << self
+        # Can't guarantee the front matter won't use the same key
+        source_document.data[collection.label] ||= self
+
+        nil
+      end
+
+      # The renderer will know how to convert this document to the
+      # needed format.
+      #
+      # @return [Jekyll::Pandoc::Renderer]
+      def renderer
+        @renderer ||= Renderer.new(site, self)
+      end
+
+      # If the format is binary, we need to copy the tempfile to the
+      # destination.
+      #
+      # @return [nil]
+      def write(dest)
+        super
+
+        return unless binary?
+
+        path = destination(dest)
+
+        FileUtils.rm path
+        FileUtils.cp rendered_path, path
+
+        nil
+      end
+
+      # Detect if the format is binary.  The type is set from the
+      # collection label, which in turn is the Pandoc-supported format.
+      #
+      # @return [Boolean]
+      def binary?
+        BINARY_FORMATS.include? type
+      end
+
+      # Generate the destination from the URL and change .html to the
+      # output extension.
+      #
+      # @return [String]
+      def destination(dest)
+        super.sub(/\.html\z/, output_ext)
+      end
+
+      def url
+        @url ||= super.tap do |u|
+          u << data['slug'] << output_ext if u.end_with? '/'
+        end
+      end
+
+      # We don't have layouts (yet?)
+      #
+      # @return [FalseClass]
+      def place_in_layout?
+        false
+      end
+
+      # It's not an asset...
+      #
+      # @return [FalseClass]
+      def asset_file?
+        false
+      end
+
+      # Nor a SASS file...
+      #
+      # @return [FalseClass]
+      def sass_file?
+        false
+      end
+
+      # Or a CoffeeScript file...
+      #
+      # @return [FalseClass]
+      def coffeescript_file?
+        false
+      end
+
+      # No need to generate an excerpt either.
+      #
+      # @return [FalseClass]
+      def generate_excerpt?
+        false
+      end
+
+      def generate_excerpt; end
+    end
+  end
+end

data/lib/jekyll/pandoc/documents/bound.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../document'
+require_relative '../renderers/binder'
+
+module Jekyll
+  module Pandoc
+    module Documents
+      # A bound document is printed, cut and bound with pegament (or
+      # sewn, etc.)
+      class Bound < Jekyll::Pandoc::Document
+        def read_content(**)
+          self.content = ''
+          nil
+        end
+
+        # Adds relations to source documents
+        #
+        # @return [nil]
+        def read_post_data
+          if data.key? 'uuid'
+            require 'securerandom'
+            data['uuid'] = SecureRandom.uuid
+          end
+
+          source_document.source_document.data['bound'] =
+            source_document.data['bound'] = self
+
+          source_document.source_document.data['formats'] ||= []
+          source_document.source_document.data['formats'] << self
+
+          nil
+        end
+
+        # Binding
+        #
+        # @return [Jekyll::Pandoc::Renderers::Binder]
+        def renderer
+          @renderer ||= Jekyll::Pandoc::Renderers::Binder.new(site, self)
+        end
+
+        # The file is always binary
+        #
+        # @return [TrueClass]
+        def binary?
+          true
+        end
+
+        # PDFs can't be rendered with Liquid
+        #
+        # @return [FalseClass]
+        def render_with_liquid?
+          false
+        end
+      end
+    end
+  end
+end