make_pdf-jekyll 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d09dc6c6f9822fd4b47f10deded424f1cbe2f7766de5fc928ff3a9dd6a6469b
-  data.tar.gz: 06c2c69b10b75f5034629c315a376cd7c47f3606df2f77fb2f3405cbec12d092
+  metadata.gz: b5ca4768cc346d06fd2b534d43a33232e50ba7054da2974ca89bf53d87eb052f
+  data.tar.gz: e5fa0a4c6aa2affb970cbd9e950d0af1b359ed60caadad94874924e3c716f88f
 SHA512:
-  metadata.gz: 862703fcd0e8f7d88ec5a2e25ed96b3ad9b96411556863656d5f3b367d8de08d87ccfe51ca9e38918d1a0d3fb4d66dac69d8c5cd2917c461cbf8492ed8f4fa23
-  data.tar.gz: de78393e5aed6ae9543b6f9ea799675a795ee65c4472802f8e9602277e373173900bf8376841526c269812f7fbc5e1839af70e40579140f3289819f011e95eb2
+  metadata.gz: 80ef0cd96743d8ec50fd55de00716963e80bf1c9842d4c1578131c9a685758dcc235280555f218d8022780c090768201623fdcc3aa743a7b1d68eeb4941de6c6
+  data.tar.gz: a0a030c29b3fb29fbf6a42b8c63067eb8af4d5540518431fd41097726d23ffa6d7acbf530eb2a2c11d3c7356b239efcb5385e16511f8557f0c2d8782c459f173

data/lib/make_pdf/chrome.rb

@@ -23,16 +23,16 @@ module MakePDF
       "animation-time-budget": nil,
     } 
 
-    def initialize(source_url, output_dir, **options)
-      super(source_url, output_dir, command: COMMAND, **options.merge(DEFAULT_OPTIONS))
+    def initialize(**options)
+      super(command: COMMAND, **options.merge(DEFAULT_OPTIONS))
     end
 
-    def map_key(key, value)
+    def map_option_key(key, value)
       case key
-      when 'source_url'
-        [ "--url", value ]
-      when 'output_filename'
-        [ "--pdf", value ]
+      when 'source-url'
+        [ '--url', value ]
+      when 'output-filename'
+        [ '--pdf', value ]
       when DEFAULT_OPTIONS.keys.method(:include?)
         case value
         when false, nil?

data/lib/make_pdf/command_based.rb

@@ -8,11 +8,14 @@ module MakePDF
       attr_reader :base
 
       def make_arguments(*options, **more)
-        [ options, more.map do |key, value|
-          map_key(key.to_s, value)
-        end ].flatten.map do |arg| 
-          arg.to_s
-        end
+        [ 
+          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
 
@@ -24,13 +27,12 @@ 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(source_url, output_filename, base_path:, **options)
+      def write(source_url, output_filename, **options)
         logger.info("converting #{source_url} with #{@command}")
         arguments = make_arguments(
           command: @command,
@@ -47,11 +49,14 @@ module MakePDF
         logger.info("pdf-writer: Wrote #{output_filename}")
       end
 
-      def output_for(file, base_path:, version: [], **options)
+      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 = File.dirname(file)
+          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

@@ -1,114 +1,160 @@
 require 'jekyll'
 require 'make_pdf'
+require 'path_of'
 
 module MakePDF
-
   LOG_NAME = "make_pdf:"
+
   # MakePDF Jekyll plugin
   class Jekyll
+    attr_reader :reason
 
-    class Logger
+    def valid?
+      @reason.nil?
+    end
 
-      def initialize(logger)
-        @logger = logger
-      end
+    def check_failure(condition, message)
+      @reason = message if condition
+      condition
+    end
 
-      def message(*args, **options)
-        @logger.message(LOG_NAME, *args, **options)
-      end
+    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
 
-      def warn(*args, **options)
-        @logger.warn(LOG_NAME, *args, **options)
-      end
+    def initialize(current_doc, **options)
+      @file     = current_doc.destination(@base_source)
+      @options = filter_options(current_doc, **options)
+      splited_url = site.config["url"].match(Regexp.new("^\(.*\)://\([^/]+\)/?.*$")).to_a
+      @options[:input_base_url] ||= site.baseurl
+      @options[:input_host] ||= splited_url[2]
+      logger.debug("base_paths: input → #{@options[:input_base_url]} output → #{@options[:output_base_path]} host → #{@options[:input_host]}")
 
-      def info(*args, **options)
-        @logger.info(LOG_NAME, *args, **options)
-      end
+      current_options = make_options(@options, site_options, filter_options(current_doc))
+      output_dir = @options[:output_dir] || path_of(site.dest).dirname
+
+      logger.debug("options : #{current_options}")
+
+      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")
 
-      def debug(*args, **options)
-        @logger.debug(LOG_NAME, *args, **options)
+      writer = current_options[:writer]
+      return if check_failure(writer.nil?, "No writer defined for #{current_doc.name} (#{writer})")
+
+      logger.info(" processing #{current_doc.name}")
+      @writer = MakePDF.const_get(writer.capitalize).new(logger:, **current_options)
+    end
+
+    def targets
+      @options[:targets] || ""
+    end
+
+    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
 
-    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
-          @logger      = Logger.new(::Jekyll.logger)
-
-          @logger.debug("Initialized with #{@options}. #{@base_source}")
+    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
 
-        current_options = @options.merge(current_doc.data)
-        @logger.debug(current_options)
-        bail = lambda do |error|
-          @logger.debug(error)
-          false
+    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
 
-        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
+    class << self
+      include PathManip
+      attr_reader :site_options, :site
 
-        @logger.info(" processing #{current_doc.name}")
+      def make_options(options, *more_options)
+        return {} if options.nil?
 
-        @writer.new(file, output_dir, base_source: @base_source, logger: @logger, **current_options)
+        [ options, more_options ].flatten
+          .reduce(:merge)
+          .transform_keys do |key|
+            key.to_s.sub("-", "_").to_sym
+          end
       end
 
-      def process(current_doc)
-        writer = setup(current_doc)
+      def logger(**options)
+        @logger ||= MakePDF::Logger.new(**options)
+      end
 
-        @logger.debug(" Ignoring #{current_doc.destination("")}")
-        return if writer === false
+      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
+        input_location  = path_of(site.dest)
+        input_base_url = relative_path_of(site.baseurl)
+        @site_options = { 
+          :output_base_path => site.source, 
+          input_location:,
+          input_base_url:,
+          :input_scheme => "file"
+        }.merge(make_options(@site.config["make-pdf"], options))
+        logger.debug("Initialized with #{self.site_options}.")
+      end
 
-        options = current_doc.data['targets']&.split(';') || []
-        file = current_doc.destination(@site.dest)
+      def process(current_doc, **options)
+        setup(current_doc.site, **options) if @site.nil?
 
-        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
+        processor = self.new(current_doc)
 
-      def render_option(writer, file, **options)
-        @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
-            @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
+        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(LOG_NAME, "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,20 +1,10 @@
 # frozen_string_literal: true
 
-require 'selenium-webdriver'
+require 'fileutils'
+require 'path_of'
 
 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))
@@ -22,43 +12,98 @@ module MakePDF
   end
 
   class Logger
-    def debug(*args)
+    LEVELS = [ :debug, :info, :warn, :error ]
+
+    def level
+      @min_level || 0
+    end
+
+    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
 
-    alias info debug
-    alias warn debug
-    alias error debug
+    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_url:, output_base_path:, input_scheme: "file", input_host: nil, logger: Logger.new() ,**options)
       @logger = logger
-      @options = options
+      raise ArgumentError.new("Scheme `#{input_scheme}` requires an `input_host`.") if input_scheme != "file" && input_host.nil?
+      @options = options.merge({ input_base_url:, output_base_path:, input_scheme:, input_host: })
+
     end
     
-    def make_source_url(file, base_path:, base_url: nil, **options)
-      base_path = Pathname.new(base_path).realpath
-      target_file = Pathname.new(file).realpath.relative_path_from(base_path)
-      if (base_url != "file:")
-        return base_url + target_file.to_s
+    def make_relative_file(file, input_location:, **options)
+      path_of(file).relative_path_from(path_of(input_location))
+    end
+
+    def make_source_url(file, input_base_url:, output_base_path:, input_scheme: , input_host: , input_location:, **options)
+      target_file = make_relative_file(file, input_location:, **options)
+      input_location = path_of(input_location)
+      input_base_url = relative_path_of(input_base_url)
+      if (input_scheme != "file")
+        return input_scheme + "://" + input_host + "/" + (input_base_url / target_file).to_path
       else
-        return base_path + target_file.to_s
+        return (input_location / input_location / target_file).to_path
       end
     end
 
-    def make_pdf_filename(file, **options)
-      path_of(file).basename.sub_ext(".pdf")
+    def make_pdf_filename(file, output_base_path:, input_location:, output_dir:, **options)
+      base_path = path_of(output_base_path) 
+      filepath = make_relative_file(file, input_location:).sub_ext(".pdf")
+      result = base_path / relative_path_of(output_dir) / filepath
+      @logger.verbose("make_pdf_filename(#{file}, #{output_base_path}) → base_path: #{base_path}, filepath: #{filepath} ⇒ #{result}")
+      result
     end
 
-    def make_output_filename(file, base_path:, **options)
-      filename = make_pdf_filename(file, base_path:, **options) 
-      output = @output_dir / filename
-      @logger.debug("filenane : #{filename} output_dir: #{output_dir} output_filename: #{output}")
+    def make_output_filename(file, input_location:, output_base_path:, output_dir: ".", **options)
+      @logger.verbose("make_output_filename(#{file}, #{input_location}, #{output_base_path})")
+      filename = make_pdf_filename(file, output_base_path:, output_dir:, input_location:,  **options) 
+      output_base_path = path_of(output_base_path)
+      output = output_base_path / relative_path_of(output_dir) / filename
+      FileUtils::mkdir_p(output.dirname)
+      @logger.debug("filename: #{filename} ⇒ #{output}")
       output
     end
 
@@ -73,7 +118,6 @@ module MakePDF
       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.3
+  version: 0.0.5
 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: []