make_pdf-jekyll 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97065b7cf75979dc847f0d82e96bf54229ea7dc4329eab0216a899ac6c72496a
-  data.tar.gz: cc8b2e3a7a25fb598079829a4198679214ac9a9e672a20c7e4fd1ea71f8cbf0e
+  metadata.gz: e5a21bc7883012692bab3b448615f5a40c58a37566c23d678e67f7f4cad520de
+  data.tar.gz: 905cf312025602478eebabd00a45477603f40e2785261297e5312321bf3c1d90
 SHA512:
-  metadata.gz: 5926bb93054a88d248eef00b4c5aa06d00768f3c7ced9d1b79fdcb713de3e732922406f4d0b365cc933d956a912992307e18ee0ac1cbc6fc612f1feb1bf3033a
-  data.tar.gz: 18ecbb2c38aabde9c0994fd6a4fb295a23d7b0cf1ef7c3cb7eabc5c508e0e587f7fc3484955f6a5248b0a24c0c8ca332295947ac263fd4803d7c9d3c3675fdc8
+  metadata.gz: 80b67fdfb51e5b34d3eebac122a4d6793d543c80c27ff9b416d63cee957928c229605a4ec4f81dd71099f0c403bfa74c4a5112ba93c1ded4cb0e4f7a1549e4a0
+  data.tar.gz: b30b0279151ba01a329c5f0e1d99c3ddc5e2677ba85704065c0fe187c080ad327cc5661bbd3014c6a94970b97df34aa527ce2525043fb87af009033c119a64d8

data/lib/make_pdf/chrome.rb

@@ -3,9 +3,48 @@ require "make_pdf/command_based"
 module MakePDF
   class Chrome < CommandBased::Writer
     COMMAND = 'chrome-headless-render-pdf'
+    DEFAULT_OPTIONS = { # options from 'chrome-headless-render-pdf --help'
+      "chrome-binary": nil,
+      "chrome-option": nil,
+      "remote-host": nil,
+      "remote-port": nil,
+      "no-margins": true,
+      "include-background": true,
+      "landscape": false,
+      "window-size": nil,
+      "paper-width": nil,
+      "paper-height": nil,
+      "page-ranges": nil,
+      "scale": nil,
+      "display-header-footer": false,
+      "header-template": nil,
+      "footer": nil,
+      "js-time-budget": nil,
+      "animation-time-budget": nil,
+    } 
 
-    def initialize(source_url, output_dif, **options)
-      super(source_url, output_dif, command: COMMAND, **options)
+    def initialize(**options)
+      super(command: COMMAND, **options.merge(DEFAULT_OPTIONS))
+    end
+
+    def map_option_key(key, value)
+      case key
+      when 'source-url'
+        [ '--url', value ]
+      when 'output-filename'
+        [ '--pdf', value ]
+      when DEFAULT_OPTIONS.keys.method(:include?)
+        case value
+        when false, nil?
+          []
+        when true, ""
+          [ "--#{key.to_s}" ]
+        else
+          [ "--#{key.to_s}", value ]
+        end
+      else
+        []
+      end
     end
   end
 end

data/lib/make_pdf/command_based.rb

@@ -7,8 +7,15 @@ module MakePDF
     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?}" })
+      def make_arguments(*options, **more)
+        [ 
+          options.map { |val| val.to_s },
+          more
+          .transform_keys { |key| key.to_s.gsub('_','-') }
+          .filter_map do |key, value|
+            map_option_key(key, value.to_s)
+          end
+        ].flatten
       end
     end
 
@@ -20,35 +27,36 @@ module MakePDF
         '--'
       end
 
-      def initialize(url, output_dir, command: COMMAND, **options)
-        super(url, output_dir, **options)
+      def initialize(command: COMMAND, **options)
+        super(**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)
+      def write(source_url, output_filename, **options)
+        logger.info("converting #{source_url} with #{@command}")
         arguments = make_arguments(
           command: @command,
-          url:,
-          pdf: output
+          source_url:,
+          output_filename:,
+          **options
         )
-        IO.popen([@command] + arguments, {:err =>[ :child, :out]}) do |pipe| 
-          std_out = pipe.read
+        logger.debug("Executing #{@command} #{arguments}")
+        std_out = IO.popen([@command] + arguments, {:err =>[ :child, :out]}) do |pipe| 
+          pipe.read
         end
-
-        raise std_out if ($? != 0)
-        logger.info("pdf-writer (#{command}): Wrote #{output}")
+        status = $?
+        raise RuntimeError.new("Failure executing #{command} with #{arguments}.\n\noutput:\n\n---\n#{std_out}\n---\n") if status != 0
+        logger.info("pdf-writer: Wrote #{output_filename}")
       end
 
-      def output_for(file, base_path:, version: [], **options)
-        if @output.nil?
-          path = File.dirname(file)
+      def output_for(file, output_base_path: ".", version: [], **options)
+        output_base_path = Pathname.new(output_base_path)
+        file = Pathname.new(file)
+
+        if @output_dir.nil?
+          path = output_base_path / file.dirname
         else
-          path = File.expand_path(relative_path(file, base_path), @output)
+          path = File.expand_path(relative_path(file, output_base_path), @output_dir)
         end
 
         FileUtils.mkdir_p path

data/lib/make_pdf/jekyll.rb

@@ -2,87 +2,152 @@ require 'jekyll'
 require 'make_pdf'
 
 module MakePDF
+  LOG_NAME = "make_pdf:"
 
   # MakePDF Jekyll plugin
   class Jekyll
+    attr_reader :reason
 
-    class << self
-      include PathManip
-      attr_reader :file, :site, :current_doc, :options, :command, :output
+    def valid?
+      @reason.nil?
+    end
 
-      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
+    def check_failure(condition, message)
+      @reason = message if condition
+      condition
+    end
 
-          ::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
+    def filter_options(document, **options)
+      document.data.filter_map do |key, value|
+        key = key.to_s
+        if key == "make-pdf"
+          possible = {
+            "" => true,
+            "true" => true,
+            "yes" => true,
+            "false" => false,
+            "no" => false
+          }
+
+          [ key, possible[value.downcase] ]
+        else
+          [ key.sub("make-pdf-", "").to_sym, value ] if key.start_with?("make-pdf-")
         end
+      end.to_h.merge(options)
+    end
 
-        writer = current_options['writer']
-        return bail.call("No writer defined for #{current_doc.name} (#{writer})") if writer.nil?
+    def initialize(current_doc, **options)
+      @file     = current_doc.destination(@base_source)
+      @options = filter_options(current_doc, **options)
+      logger.debug("base_paths: input → #{@options[:input_base_path]} output → #{@options[:output_base_path]}")
 
-        @writer = MakePDF.const_get(current_options['writer'].capitalize)
+      current_options = make_options(@options, site_options, filter_options(current_doc))
+      output_dir = @options[:output_dir] || path_of(site.dest).dirname
 
-        file   = current_doc.destination(@base_source)
-        output_dir = @options['output_dir'] || path_of(file).dirname
+      logger.debug("options : #{current_options}")
 
-        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
+      return if check_failure(File.extname(@file) != '.html', "#{@file} is not an html")
+      return if check_failure(current_options[:make_pdf].nil? && !@opt_in, "#{current_doc.name} has not opted in")
+      return if check_failure(current_options[:make_pdf] == false, "#{current_doc.name} has opted out")
 
-        ::Jekyll.logger.info("make_pdf:", " processing #{current_doc.name}")
+      writer = current_options[:writer]
+      return if check_failure(writer.nil?, "No writer defined for #{current_doc.name} (#{writer})")
 
-        @writer.new(file, output, logger: ::Jekyll.logger, **current_options)
-      end
+      logger.info(" processing #{current_doc.name}")
+      @writer = MakePDF.const_get(writer.capitalize).new(logger:, **current_options)
+    end
 
-      def process(current_doc)
-        writer = setup(current_doc)
+    def targets
+      @options[:targets] || ""
+    end
 
-        ::Jekyll::logger.debug("make_pdf:", " Ignoring #{current_doc.destination("")}")
-        return if writer === false
+    def method_missing(method_name, *args, **options)
+      if not Jekyll.site_options.nil? and Jekyll.site_options.include?(method_name)
+        return Jekyll.site_options[method_name]
+      elsif Jekyll.respond_to?(method_name, false)
+        return Jekyll.send(method_name, *args, **options)
+      else
+        super
+      end
+    end
 
-        options = current_doc.data['targets']&.split(';') || []
-        file = current_doc.destination(@site.dest)
+    def render_option(**options)
+      logger.debug("MakePDF rendering options #{options}")
+
+      attempted = 0
+      begin
+        @writer.process(@file, **options.merge(@options))
+      rescue => error
+        attempted += 1
+        if attempted <= 2
+          logger.warn("Failed to generate #{@file} retrying #{attempted}")
+          logger.warn("ERROR: #{error}")
+          retry
+        else
+          logger.warn("Skipping generation of #{@file} with #{options}")
+          raise error
+        end
+      end
+    end
 
-        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(",")) }
+    def process(**options)
+      render_option(**options)
+      unless self.targets.nil?
+        self.targets.split(",").each do |option|
+          render_option(version: option.split(","), **options)
+        end
       end
+    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
+    class << self
+      include PathManip
+      attr_reader :site_options, :site
+
+      def make_options(options, *more_options)
+        return {} if options.nil?
+
+        [ options, more_options ].flatten
+          .reduce(:merge)
+          .transform_keys do |key|
+            key.to_s.sub("-", "_").to_sym
           end
+      end
+
+      def logger(**options)
+        @logger ||= MakePDF::Logger.new(**options)
+      end
+
+      def setup(site, **options)
+        return unless @site.nil?
+
+        config = site.config["make-pdf"]||{}
+        logger(logger: ::Jekyll.logger, level: (config["log-map-level"] || :debug).to_sym, verbose: config['log-verbose'])
+        @site         = site
+        @site_options = { 
+          :output_base_path => site.source, 
+          :input_base_path => site.dest,
+          :input_scheme => "file"
+        }.merge(make_options(@site.config["make-pdf"], options))
+        logger.debug("Initialized with #{self.site_options}.")
+      end
+
+      def process(current_doc, **options)
+        setup(current_doc.site, **options) if @site.nil?
+
+        processor = self.new(current_doc)
+
+        unless processor.valid?
+          logger.debug "Ignoring #{current_doc.name} ⇒ #{processor.reason}"
+          return false
         end
+
+        processor.process(**@site_options)
       end
     end
   end
+end
 
-  ::Jekyll.logger.info('MakePDF:', "loaded")
-  ::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
-    MakePDF::Jekyll.process(doc)
-  end
+::Jekyll.logger.info("Loaded #{MakePDF::LOG_NAME} plugin")
+::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
+  MakePDF::Jekyll.process(doc)
 end

data/lib/make_pdf.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'selenium-webdriver'
+require 'fileutils'
 
 module MakePDF
   module PathManip
@@ -22,51 +22,111 @@ module MakePDF
   end
 
   class Logger
-    def debug(*args)
+    LEVELS = [ :debug, :info, :warn, :error ]
+
+    def level
+      @min_level || 0
     end
 
-    alias info debug
-    alias warn debug
-    alias error debug
+    def initialize(logger: nil, level: :debug, verbose: false)
+      @logger = logger
+      @min_level = LEVELS.index(level) || 2
+      @verbose = verbose
+      write(:debug, "logging at least level #{LEVELS[@min_level].to_s} with #{logger}")
+    end
+
+    def write(level, *args)
+      print("#{level.to_s} : ", *args.map do |msg|
+        if (msg.size > 80)
+          msg[0..79] + "…"
+        else
+          msg
+        end
+      end.join("\n"), "\n")
+      return
+    end
+
+    def verbose(*args)
+      if (@verbose)
+        @logger.send(LEVELS[self.level], LOG_NAME, *args)
+      end
+    end
+
+    def method_missing(method_name, *args, **options)
+      if @logger.nil? and LEVELS.include?(method_name)
+        return write(method_name, *args)
+      end
+
+      if accepts?(method_name)
+        @logger.send(LEVELS[[LEVELS.index(method_name), self.level].max], LOG_NAME, *args, **options)
+      else
+        super
+      end
+    end
+
+    def accepts?(method_name)
+      LEVELS.include?(method_name) and @logger.respond_to?(method_name, false) 
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      accepts?(method_name) || super
+    end
   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)
+    def initialize(input_base_path:, output_base_path:, input_scheme: "file", logger: Logger.new() ,**options)
       @logger = logger
-      @options = options
+      @options = options.merge({ input_base_path:, output_base_path:, input_scheme: })
+    end
+    
+    def make_source_url(file, input_base_path:, output_base_path:, input_scheme: , **options)
+      target_file = relative_path(file, input_base_path:, **options)
+      if (input_scheme != "file")
+        return input_scheme + "://" + output_base_path + target_file.to_s
+      else
+        return input_base_path + target_file.to_s
+      end
     end
 
-    def source_url(file, base_path:Pathname.new("."), base_url: "file:/", version: [], separator: ",", **options)
-      file_path = path_of(file)
+    def relative_path(file, input_base_path:, **options)
+      base_path = Pathname.new(input_base_path)
+      result = Pathname.new(file).relative_path_from(base_path).dirname
+      @logger.verbose("relative_path(#{file}, #{input_base_path}) → base_path: #{base_path} ⇒ #{result}")
+      result
+    end
 
-      options = unless version.empty? 
-                  "##{version.join(separator)}"
-                else
-                  ""
-                end 
-      "#{base_url}#{relative_path(file_path, base_path)}/#{file_path.basename}#{options}"
+    def make_pdf_filename(file, input_base_path:, **options)
+      base_path = relative_path(file, input_base_path:, **options)
+      filename = Pathname.new(file).basename.sub_ext(".pdf")
+      result = base_path / filename
+      @logger.verbose("make_pdf_filename(#{file}, #{input_base_path}) → base_path: #{base_path}, filename: #{filename} ⇒ #{result}")
+      result
     end
 
-    def output_for(file, version, **options)
-      output = path_of(file).basename(".pdf").to_s
-      path_of(@output_dir, output + version.join("_") + ".pdf")
+    def make_output_filename(file, input_base_path:, output_base_path:, output_dir: ".", **options)
+      @logger.verbose("make_output_filename(#{file}, #{input_base_path}, #{output_base_path})")
+      filename = make_pdf_filename(file, input_base_path:, **options) 
+      output_base_path = Pathname.new(output_base_path)
+      output = output_base_path / Pathname.new(output_dir) / filename
+      FileUtils::mkdir_p(output.dirname)
+      @logger.debug("filename: #{filename} ⇒ #{output}")
+      output
     end
 
     def process(file, version: [], **options)
       options = @options.merge(options)
+      output_filename = make_output_filename(file, version: version, **options)
       write(
-        source_url(file, vesrsion: version, **options),
-        output_for(file, version: version, **options),
+        make_source_url(file, vesrsion: version, **options),
+        output_filename,
         **options
       )
+      output_filename
     end
   end
-
 end
 
 Dir[File.join(__dir__, 'make_pdf/', '**', '*.rb')].each do |file| 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: make_pdf-jekyll
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Victor Bogado da Silva Lins
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-08-27 00:00:00.000000000 Z
 dependencies: []
 description: Allows that some documents, or pages to have a pdf version pre generated.
 email: 'victor@bogado.net  '
@@ -24,6 +25,7 @@ homepage: https://rubygems.org/gems/make_pdf-jekyll
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -38,7 +40,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.3.25
+signing_key:
 specification_version: 4
 summary: Create PDF along side of HTML files for site.
 test_files: []