make_pdf-jekyll 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97065b7cf75979dc847f0d82e96bf54229ea7dc4329eab0216a899ac6c72496a
+  data.tar.gz: cc8b2e3a7a25fb598079829a4198679214ac9a9e672a20c7e4fd1ea71f8cbf0e
+SHA512:
+  metadata.gz: 5926bb93054a88d248eef00b4c5aa06d00768f3c7ced9d1b79fdcb713de3e732922406f4d0b365cc933d956a912992307e18ee0ac1cbc6fc612f1feb1bf3033a
+  data.tar.gz: 18ecbb2c38aabde9c0994fd6a4fb295a23d7b0cf1ef7c3cb7eabc5c508e0e587f7fc3484955f6a5248b0a24c0c8ca332295947ac263fd4803d7c9d3c3675fdc8

data/lib/make_pdf/chrome.rb

@@ -0,0 +1,11 @@
+require "make_pdf/command_based"
+
+module MakePDF
+  class Chrome < CommandBased::Writer
+    COMMAND = 'chrome-headless-render-pdf'
+
+    def initialize(source_url, output_dif, **options)
+      super(source_url, output_dif, command: COMMAND, **options)
+    end
+  end
+end

data/lib/make_pdf/command_based.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+require 'pathname'
+require 'make_pdf'
+
+module MakePDF
+  module CommandBased
+    module Arguments
+      attr_reader :base
+
+      def make_arguments(options = [], **more)
+        options.concat(more.map { |key, value| "#{self.class.prefix}#{key}#{"=#{value}" unless value == true || value.nil?}" })
+      end
+    end
+
+    class Writer < PDFWriter
+      attr_reader :command, :options
+      include Arguments
+
+      def self.prefix
+        '--'
+      end
+
+      def initialize(url, output_dir, command: COMMAND, **options)
+        super(url, output_dir, **options)
+        @command = command
+        @options = options
+      end
+
+      def write(file, base_path:, **options)
+        logger.info("pdf-writer (#{command}): converting #{file}")
+
+        url = source_url(file, base_path:, **options),
+        output = output_for(file, base_path:, **options)
+        arguments = make_arguments(
+          command: @command,
+          url:,
+          pdf: output
+        )
+        IO.popen([@command] + arguments, {:err =>[ :child, :out]}) do |pipe| 
+          std_out = pipe.read
+        end
+
+        raise std_out if ($? != 0)
+        logger.info("pdf-writer (#{command}): Wrote #{output}")
+      end
+
+      def output_for(file, base_path:, version: [], **options)
+        if @output.nil?
+          path = File.dirname(file)
+        else
+          path = File.expand_path(relative_path(file, base_path), @output)
+        end
+
+        FileUtils.mkdir_p path
+
+        suffix = if version.empty? then "" else "_#{version.join("_")}" end
+        File.expand_path(File.basename(file, ".html") + "#{suffix}.pdf", path)
+      end
+    end
+  end
+end

data/lib/make_pdf/firefox.rb

@@ -0,0 +1,31 @@
+require "make_pdf/command_based"
+
+# TODO: In progress.
+# Firefox css media don't work well anyway.
+#
+module MakePDF
+  class FirefoxPDFWriter < PDFWriter
+    include CommandBased::Arguments
+
+    def self.prefix
+      '-'
+    end
+
+    def initialize(options)
+      Jekyll.logger.info('MakePDF firefox:', options)
+      @args = make_arguments(**options)
+      @driver_opts = Selenium::WebDriver::Firefox::Options.new(args: @opts)
+      setup
+    end
+
+    def setup
+      Jekyll.logger.info('MakePDF firefox: start driver')
+      @driver = Selenium::WebDriver.for :firefox, capabilities: @driver_opts
+    end
+
+    def write(url, output)
+      @driver.get(url)
+      @driver.save_print_page output
+    end
+  end
+end

data/lib/make_pdf/jekyll.rb

@@ -0,0 +1,88 @@
+require 'jekyll'
+require 'make_pdf'
+
+module MakePDF
+
+  # MakePDF Jekyll plugin
+  class Jekyll
+
+    class << self
+      include PathManip
+      attr_reader :file, :site, :current_doc, :options, :command, :output
+
+      def setup(current_doc)
+        if @site.nil?
+          @site        = current_doc.site
+          @options     = @site.config['make-pdf'] || {}
+          @opt_in      = @options['write-by-default'] || false
+          @base_url    = @options['source'] || "file:/"
+          @base_source = @site.dest
+
+          ::Jekyll.logger.debug("make_pdf:", "Initialized with #{@options}. #{@base_source}")
+        end
+          
+        current_options = @options.merge(current_doc.data)
+        ::Jekyll::logger.debug("make-pdf", current_options)
+        bail = lambda do |error|
+          ::Jekyll.logger.debug("make_pdf:", error)
+          false
+        end
+
+        writer = current_options['writer']
+        return bail.call("No writer defined for #{current_doc.name} (#{writer})") if writer.nil?
+
+        @writer = MakePDF.const_get(current_options['writer'].capitalize)
+
+        file   = current_doc.destination(@base_source)
+        output_dir = @options['output_dir'] || path_of(file).dirname
+
+        return bail.call("#{file} is not an html") if File.extname(file) != '.html'
+        return bail.call("#{current_doc.name} has not opted in") if current_doc.data['make-pdf'].nil? && !@opt_in
+        return bail.call("#{current_doc.name} has opted out")if current_doc.data['make-pdf'] == false
+
+        ::Jekyll.logger.info("make_pdf:", " processing #{current_doc.name}")
+
+        @writer.new(file, output, logger: ::Jekyll.logger, **current_options)
+      end
+
+      def process(current_doc)
+        writer = setup(current_doc)
+
+        ::Jekyll::logger.debug("make_pdf:", " Ignoring #{current_doc.destination("")}")
+        return if writer === false
+
+        options = current_doc.data['targets']&.split(';') || []
+        file = current_doc.destination(@site.dest)
+
+        render_option(writer, file, base_path: @site.dest, base_url: @base_url)
+        options.each { |option| render_option(writer, file, base_path: @site.dest, base_url: @base_url,  version: option.split(",")) }
+      end
+
+      def render_option(writer, file, **options)
+        ::Jekyll.logger.debug('MakePDF options:', options)
+
+        raise "File #{file} is not accessible" unless File.readable?(file)
+
+        attempted = 0
+        begin
+          writer.write(file, **options)
+        rescue => error
+          attempted += 1
+          if attempted <= 2
+            ::Jekyll.logger.warn("MakePDF: Failed to generate #{file} retrying #{attempted}")
+            ::Jekyll.logger.warn("MakePDF: ERROR: #{error}")
+            retry
+          else
+            ::Jekyll.logger.error("MakePDF: Skipping generation of #{file} with #{options}")
+            raise error
+          end
+        end
+      end
+    end
+  end
+
+  ::Jekyll.logger.info('MakePDF:', "loaded")
+  ::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
+    MakePDF::Jekyll.process(doc)
+  end
+end

data/lib/make_pdf.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'selenium-webdriver'
+
+module MakePDF
+  module PathManip
+    def path_of(base, *path_components)
+      other = unless path_components.empty?
+                path_components
+                  .map { |component| path_of(component) }
+                  .sum Pathname.new(".")
+              else
+                Pathname.new("")
+              end
+      base = Pathname.new(".") if base.nil?
+      if base.instance_of?(Pathname) then base else Pathname.new(base) end + other
+    end
+
+    def relative_path(file, base_path)
+      path_of(file).relative_path_from(path_of(base_path))
+    end
+  end
+
+  class Logger
+    def debug(*args)
+    end
+
+    alias info debug
+    alias warn debug
+    alias error debug
+  end
+
+  class PDFWriter
+    include PathManip
+    attr_reader :output_dir, :source_url, :logger
+
+    def initialize(source_url, output_dir, logger: Logger.new() ,**options)
+      @source_url = source_url
+      @output_dir = path_of(output_dir)
+      @logger = logger
+      @options = options
+    end
+
+    def source_url(file, base_path:Pathname.new("."), base_url: "file:/", version: [], separator: ",", **options)
+      file_path = path_of(file)
+
+      options = unless version.empty? 
+                  "##{version.join(separator)}"
+                else
+                  ""
+                end 
+      "#{base_url}#{relative_path(file_path, base_path)}/#{file_path.basename}#{options}"
+    end
+
+    def output_for(file, version, **options)
+      output = path_of(file).basename(".pdf").to_s
+      path_of(@output_dir, output + version.join("_") + ".pdf")
+    end
+
+    def process(file, version: [], **options)
+      options = @options.merge(options)
+      write(
+        source_url(file, vesrsion: version, **options),
+        output_for(file, version: version, **options),
+        **options
+      )
+    end
+  end
+
+end
+
+Dir[File.join(__dir__, 'make_pdf/', '**', '*.rb')].each do |file| 
+  print "#{file}\n"
+  require file
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: make_pdf-jekyll
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Victor Bogado da Silva Lins
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Allows that some documents, or pages to have a pdf version pre generated.
+email: 'victor@bogado.net  '
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/make_pdf.rb
+- lib/make_pdf/chrome.rb
+- lib/make_pdf/command_based.rb
+- lib/make_pdf/firefox.rb
+- lib/make_pdf/jekyll.rb
+homepage: https://rubygems.org/gems/make_pdf-jekyll
+licenses:
+- MIT
+metadata: {}
+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: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Create PDF along side of HTML files for site.
+test_files: []