make_pdf-jekyll 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5a21bc7883012692bab3b448615f5a40c58a37566c23d678e67f7f4cad520de
-  data.tar.gz: 905cf312025602478eebabd00a45477603f40e2785261297e5312321bf3c1d90
+  metadata.gz: 68f4407fd68b80e7a2f87419480396c0eb7b543ddf86e5bcd8a8b4c60f9d71a6
+  data.tar.gz: 85e8793030dc76e217a4f1882d3befd3fc4a7d49ed01efe888a6789198d6730f
 SHA512:
-  metadata.gz: 80b67fdfb51e5b34d3eebac122a4d6793d543c80c27ff9b416d63cee957928c229605a4ec4f81dd71099f0c403bfa74c4a5112ba93c1ded4cb0e4f7a1549e4a0
-  data.tar.gz: b30b0279151ba01a329c5f0e1d99c3ddc5e2677ba85704065c0fe187c080ad327cc5661bbd3014c6a94970b97df34aa527ce2525043fb87af009033c119a64d8
+  metadata.gz: 0f38ee9054a2ae250228ebac98ef1a97fe7e13fadeee5dba66aa1b9afb302e0f4e9cc4a9a9d35e21e28dded6af688c66362793add3fd488b877fa27a316f3a52
+  data.tar.gz: fc8c51cd0bb88aacf8ba5dfce138eeca83e71fed79ea80c60ea02e37eac7f71d1393d7c4cbd5ebece01dcc1bb8990983761c2da391ed3b932fe07f7fa9dcac14

data/lib/make_pdf/firefox.rb

@@ -12,14 +12,14 @@ module MakePDF
     end
 
     def initialize(options)
-      Jekyll.logger.info('MakePDF firefox:', options)
+      Processor.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')
+      Processor.logger.info('MakePDF firefox: start driver')
       @driver = Selenium::WebDriver.for :firefox, capabilities: @driver_opts
     end
 

data/lib/make_pdf/jekyll.rb

@@ -1,12 +1,13 @@
 require 'jekyll'
 require 'make_pdf'
+require 'path_of'
 
 module MakePDF
   LOG_NAME = "make_pdf:"
 
   # MakePDF Jekyll plugin
-  class Jekyll
-    attr_reader :reason
+  class Processor
+    attr_reader :reason, :doc, :name
 
     def valid?
       @reason.nil?
@@ -29,32 +30,42 @@ module MakePDF
             "no" => false
           }
 
-          [ key, possible[value.downcase] ]
+          [ key, possible[value.to_s.downcase] ]
         else
           [ key.sub("make-pdf-", "").to_sym, value ] if key.start_with?("make-pdf-")
         end
       end.to_h.merge(options)
     end
 
-    def initialize(current_doc, **options)
-      @file     = current_doc.destination(@base_source)
+    def initialize(site, current_doc, **options)
+      @site    = site
+      @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]}")
+      @name    = current_doc.name
 
-      current_options = make_options(@options, site_options, filter_options(current_doc))
-      output_dir = @options[:output_dir] || path_of(site.dest).dirname
+      logger.debug("base_paths: input → #{@options[:input_base_url]} output → #{@options[:output_base_path]} host → #{@options[:input_host]}")
+
+      current_options = make_options(@options, options, filter_options(current_doc))
 
       logger.debug("options : #{current_options}")
 
+      return if check_failure(current_options[:disabled], "MakePDF disabled")
+
       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")
 
-      writer = current_options[:writer]
+      writer = current_options[:writer] || site.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)
+      @doc = current_doc
+    end
+
+    def output_dir
+      @writer.output_dir
     end
 
     def targets
@@ -62,10 +73,12 @@ module MakePDF
     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)
+      if @options.include?(method_name)
+        return @options[method_name]
+      elsif not @site.options.nil? and @site.options.include?(method_name)
+        return @site.options[method_name]
+      elsif @site.respond_to?(method_name, false)
+        return @site.send(method_name, *args, **options)
       else
         super
       end
@@ -76,6 +89,7 @@ module MakePDF
 
       attempted = 0
       begin
+        logger.info("processing #{@file}")
         @writer.process(@file, **options.merge(@options))
       rescue => error
         attempted += 1
@@ -99,9 +113,19 @@ module MakePDF
       end
     end
 
-    class << self
+    class Site
       include PathManip
-      attr_reader :site_options, :site
+      attr_reader :options, :site, :logger
+
+      def default_options
+        return { 
+          output_base_path: site.source, 
+          input_location: path_of(site.dest),
+          input_base_url: relative_path_of(site.baseurl[1..]),
+          input_host: site.config["url"].match(Regexp.new("^[^:]*://\([^/]+\)/?.*$"))[1],
+          input_scheme: "file"
+        }.freeze
+      end
 
       def make_options(options, *more_options)
         return {} if options.nil?
@@ -113,41 +137,49 @@ module MakePDF
           end
       end
 
-      def logger(**options)
-        @logger ||= MakePDF::Logger.new(**options)
-      end
-
-      def setup(site, **options)
-        return unless @site.nil?
-
+      def initialize(site, **options)
         config = site.config["make-pdf"]||{}
-        logger(logger: ::Jekyll.logger, level: (config["log-map-level"] || :debug).to_sym, verbose: config['log-verbose'])
+        @logger = MakePDF::Logger.new(logger: ::Jekyll.logger, level: (config["log-map-level"] || :debug))
         @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}.")
+        @options = default_options.merge(make_options(@site.config["make-pdf"], options))
+        @queue        = []
+        logger.debug("Initialized with #{self.options}.")
       end
 
-      def process(current_doc, **options)
-        setup(current_doc.site, **options) if @site.nil?
-
-        processor = self.new(current_doc)
+      def queue(processor)
+        logger.info("Adding #{processor.name} to queue")
+        @queue.push(processor)
+      end
 
-        unless processor.valid?
-          logger.debug "Ignoring #{current_doc.name} ⇒ #{processor.reason}"
-          return false
+      def <<(doc)
+        processor = Processor.new(self, doc, **@options)
+        if processor.valid?
+          queue(processor)
+        else
+          logger.info("Skip #{doc.name} => #{processor.reason}")
         end
+      end
 
-        processor.process(**@site_options)
+      def process
+        @queue.each do |processor|
+          processor.process(**@options)
+        end
       end
     end
   end
-end
 
-::Jekyll.logger.info("Loaded #{MakePDF::LOG_NAME} plugin")
-::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
-  MakePDF::Jekyll.process(doc)
+  ::Jekyll.logger.info("Loaded #{MakePDF::LOG_NAME} plugin")
+
+  ::Jekyll::Hooks.register [:site], :after_init do |site|
+    @@site = MakePDF::Processor::Site.new(site)
+    @@site.logger.info("site :after_init #{@@site}")
+  end
+
+  ::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
+    @@site << doc
+  end
+
+  ::Jekyll::Hooks.register [:site], :post_write do |site|
+    @@site.process
+  end
 end

data/lib/make_pdf.rb

@@ -1,20 +1,10 @@
 # frozen_string_literal: true
 
 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))
@@ -77,40 +67,41 @@ module MakePDF
     include PathManip
     attr_reader :output_dir, :source_url, :logger
 
-    def initialize(input_base_path:, output_base_path:, input_scheme: "file", logger: Logger.new() ,**options)
+    def initialize(input_base_url:, output_base_path:, input_scheme: "file", input_host: nil, logger: Logger.new() ,**options)
       @logger = logger
-      @options = options.merge({ input_base_path:, output_base_path:, input_scheme: })
+      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, input_base_path:, output_base_path:, input_scheme: , **options)
-      target_file = relative_path(file, input_base_path:, **options)
+    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 + "://" + output_base_path + target_file.to_s
+        return input_scheme + "://" + input_host + "/" + (input_base_url / target_file).to_path
       else
-        return input_base_path + target_file.to_s
+        return (input_location / input_location / target_file).to_path
       end
     end
 
-    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
-
-    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}")
+    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, 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
+    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
@@ -130,6 +121,5 @@ module MakePDF
 end
 
 Dir[File.join(__dir__, 'make_pdf/', '**', '*.rb')].each do |file| 
-  print "#{file}\n"
   require file
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: make_pdf-jekyll
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Victor Bogado da Silva Lins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-27 00:00:00.000000000 Z
+date: 2025-09-03 00:00:00.000000000 Z
 dependencies: []
 description: Allows that some documents, or pages to have a pdf version pre generated.
 email: 'victor@bogado.net  '