make_pdf-jekyll 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68f4407fd68b80e7a2f87419480396c0eb7b543ddf86e5bcd8a8b4c60f9d71a6
-  data.tar.gz: 85e8793030dc76e217a4f1882d3befd3fc4a7d49ed01efe888a6789198d6730f
+  metadata.gz: 5415a398452c09f6ee1d7561494bb08ad0eba49ba4cb8e8f47ea84fd1ccc6a99
+  data.tar.gz: 1b507489b3352cdbf1bdae9f1874b1bd0009cb58be2c3bba859be9d5b6518365
 SHA512:
-  metadata.gz: 0f38ee9054a2ae250228ebac98ef1a97fe7e13fadeee5dba66aa1b9afb302e0f4e9cc4a9a9d35e21e28dded6af688c66362793add3fd488b877fa27a316f3a52
-  data.tar.gz: fc8c51cd0bb88aacf8ba5dfce138eeca83e71fed79ea80c60ea02e37eac7f71d1393d7c4cbd5ebece01dcc1bb8990983761c2da391ed3b932fe07f7fa9dcac14
+  metadata.gz: 6fc9327227686c526f29c96b6ac86fd0c1ad97a9120770c67c56a4721ab4d6ed69149864696ecaa69f53fe2ac177fc53fa2083c3345ef239bb1fc3488486d6fe
+  data.tar.gz: a5237d557f9605a594e323498c9e5e699ef5ddd0079d9ba5a3b6ebe8d01fda4cad0b55cec632d3220f74b98536ac3e2c99ccb4fb9cfeae772f5378bd3b47a895

data/lib/make_pdf/command_based.rb

@@ -33,20 +33,20 @@ module MakePDF
       end
 
       def write(source_url, output_filename, **options)
-        logger.info("converting #{source_url} with #{@command}")
+        logger.debug("converting #{source_url} with #{@command}")
         arguments = make_arguments(
           command: @command,
           source_url:,
           output_filename:,
           **options
         )
-        logger.debug("Executing #{@command} #{arguments}")
+        logger.verbose("Executing #{@command} #{arguments}")
         std_out = IO.popen([@command] + arguments, {:err =>[ :child, :out]}) do |pipe| 
           pipe.read
         end
         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}")
+        logger.verbose("pdf-writer: Wrote #{output_filename}")
       end
 
       def output_for(file, output_base_path: ".", version: [], **options)

data/lib/make_pdf/firefox.rb

@@ -12,14 +12,14 @@ module MakePDF
     end
 
     def initialize(options)
-      Processor.logger.info('MakePDF firefox:', options)
+      Processor.logger.debug('MakePDF firefox:', options)
       @args = make_arguments(**options)
       @driver_opts = Selenium::WebDriver::Firefox::Options.new(args: @opts)
       setup
     end
 
     def setup
-      Processor.logger.info('MakePDF firefox: start driver')
+      Processor.logger.debug('MakePDF firefox: start driver')
       @driver = Selenium::WebDriver.for :firefox, capabilities: @driver_opts
     end
 

data/lib/make_pdf/jekyll.rb

@@ -1,13 +1,111 @@
 require 'jekyll'
 require 'make_pdf'
 require 'path_of'
+require 'digest'
+require 'uri'
+
+require_relative '../pdf_logger.rb'
 
 module MakePDF
-  LOG_NAME = "make_pdf:"
+  LOG_NAME = 'make_pdf:'.freeze
+
+  # Site
+  #
+  # Responible for bridging the configurartions on Jekyll and setting up
+  # the conversion of PDFs
+  class MakePDFSite
+    include PathManip
+    attr_reader :options, :site, :logger, :file
+
+    def default_options
+      {
+        output_base_path: site.dest,
+        input_location: path_of(site.dest),
+        input_base_url: relative_path_of(site.baseurl[1..]),
+        input_host: URI(site.config['url']).host,
+        input_scheme: 'file'
+      }.freeze
+    end
+
+    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 initialize(site, **options)
+      raise 'site is nil' if site.nil?
+
+      @site    = site
+      config   = site.config['make-pdf'] || {}
+      @logger  = MakePDF::PdfLogger.new(logger: ::Jekyll.logger, level: config['log-map-level'].to_sym || :warn, name: LOG_NAME)
+      @options = default_options.merge(make_options(@site.config['make-pdf'], options))
+      @queue   = []
+      @hashes  = YAML::safe_load_file(metadata_file)
+
+      logger.verbose("Initialized with #{self.options}.")
+    end
+
+    def queue(processor)
+      @queue.push(processor)
+    end
+
+    def <<(doc)
+      processor = Processor.new(self, doc, **@options)
+      if processor.valid?
+        logger.debug("Adding #{processor.name} to queue")
+        queue(processor)
+      else
+        logger.verbose("Skip #{doc.name} => #{processor.reason}")
+      end
+    end
+
+    def metadata
+      'make_pdf_hashes'
+    end
+
+    def metadata_dir
+      result = Pathname.new(site.config['data_dir'])
+      Dir.mkdir(result) unless Dir.exist?(result)
+
+      result
+    end
+
+    def metadata_file
+      metadata_dir / Pathname.new("#{metadata}.yaml")
+    end
+
+    def save_hashes
+      logger.debug("Saving hash file : #{metadata_file}")
+      logger.verbose("Hashes: #{@hashes.to_yaml}")
+      File.open(metadata_file, 'w') do |file|
+        file.write(@hashes.to_yaml)
+      end
+    end
+
+    def process
+      @queue.each do |processor|
+        hash = processor.filehash
+        if hash != @hashes[processor.source.to_s]
+          processor.process(**@options)
+          @hashes[processor.source.to_s] = hash
+        else
+          processor.skip('Not changed')
+        end
+      end
+      save_hashes
+    end
+  end
 
   # MakePDF Jekyll plugin
+  #
+  # Processor is the class that process a single document.
   class Processor
-    attr_reader :reason, :doc, :name
+    attr_reader :reason, :doc, :name, :source, :file
 
     def valid?
       @reason.nil?
@@ -18,38 +116,50 @@ module MakePDF
       condition
     end
 
+    def enable(value)
+      possible = {
+        '' => true,
+        'true' => true,
+        'yes' => true,
+        'false' => false,
+        'no' => false
+      }
+
+      ['make-pdf', possible[value.to_s.downcase]]
+    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.to_s.downcase] ]
-        else
-          [ key.sub("make-pdf-", "").to_sym, value ] if key.start_with?("make-pdf-")
+        if key == 'make-pdf'
+          enable(value)
+        elsif key.start_with?('make-pdf-')
+          [key.sub('make-pdf-', '').to_sym, value]
         end
       end.to_h.merge(options)
     end
 
+    def skip(reason)
+      logger.info("Skipped #{@file} #{reason}")
+    end
+
     def initialize(site, current_doc, **options)
-      @site    = site
-      @file    = current_doc.destination(@base_source)
-      @options = filter_options(current_doc, **options)
-      @name    = current_doc.name
+      @site     = site
+      @file     = current_doc.destination(@base_source)
+      @options  = filter_options(current_doc, **options)
+      @name     = current_doc.name
+      @source   = current_doc.path
 
-      logger.debug("base_paths: input → #{@options[:input_base_url]} output → #{@options[:output_base_path]} host → #{@options[:input_host]}")
+      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))
+      current_options[:output_name] ||= Pathname.new(@name).sub_ext('.pdf')
 
       logger.debug("options : #{current_options}")
 
-      return if check_failure(current_options[:disabled], "MakePDF disabled")
+      return if check_failure(current_options[:disabled], 'MakePDF disabled')
 
       return if check_failure(File.extname(@file) != '.html', "#{@file} is not an html")
 
@@ -60,7 +170,7 @@ module MakePDF
       writer = current_options[:writer] || site.options[:writer]
       return if check_failure(writer.nil?, "No writer defined for #{current_doc.name} (#{writer})")
 
-      @writer = MakePDF.const_get(writer.capitalize).new(logger:, **current_options)
+      @writer = MakePDF.const_get(writer.capitalize).new(logger: logger, **current_options)
       @doc = current_doc
     end
 
@@ -69,101 +179,64 @@ module MakePDF
     end
 
     def targets
-      @options[:targets] || ""
+      @options[:targets] || ''
+    end
+
+    def respond_to_missing?(method_name)
+      @options.include?(method_name) ||
+        (!@site.options.nil? && @site.options.include?(method_name)) ||
+        @site.respond_to?(method_name, false)
     end
 
     def method_missing(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]
+        @options[method_name]
+      elsif !@site.options.nil? && @site.options.include?(method_name)
+        @site.options[method_name]
       elsif @site.respond_to?(method_name, false)
-        return @site.send(method_name, *args, **options)
+        @site.send(method_name, *args, **options)
       else
         super
       end
     end
 
-    def render_option(**options)
-      logger.debug("MakePDF rendering options #{options}")
+    private
 
-      attempted = 0
+    def try(identification, count)
       begin
-        logger.info("processing #{@file}")
-        @writer.process(@file, **options.merge(@options))
+        yield
       rescue => error
-        attempted += 1
-        if attempted <= 2
-          logger.warn("Failed to generate #{@file} retrying #{attempted}")
-          logger.warn("ERROR: #{error}")
+        attempt += 1
+        message = "#{identification} attempt number #{attempt} failed with #{error}"
+        if attempted < count
+          logger.warn("#{message}, retrying")
           retry
         else
-          logger.warn("Skipping generation of #{@file} with #{options}")
-          raise error
-        end
-      end
-    end
-
-    def process(**options)
-      render_option(**options)
-      unless self.targets.nil?
-        self.targets.split(",").each do |option|
-          render_option(version: option.split(","), **options)
+          logger.error("#{message}.")
         end
       end
     end
 
-    class Site
-      include PathManip
-      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?
+    public
 
-        [ options, more_options ].flatten
-          .reduce(:merge)
-          .transform_keys do |key|
-            key.to_s.sub("-", "_").to_sym
-          end
-      end
-
-      def initialize(site, **options)
-        config = site.config["make-pdf"]||{}
-        @logger = MakePDF::Logger.new(logger: ::Jekyll.logger, level: (config["log-map-level"] || :debug))
-        @site         = site
-        @options = default_options.merge(make_options(@site.config["make-pdf"], options))
-        @queue        = []
-        logger.debug("Initialized with #{self.options}.")
+    def render_option(**options)
+      logger.info("processing #{@file}")
+      logger.debug("MakePDF rendering options #{options}")
+      try("Process #{@file}", 3) do
+        @writer.process(@file, **options.merge(@options))
       end
+    end
 
-      def queue(processor)
-        logger.info("Adding #{processor.name} to queue")
-        @queue.push(processor)
-      end
+    def filehash
+      return Digest::SHA256.file(@source).hexdigest
+    end
 
-      def <<(doc)
-        processor = Processor.new(self, doc, **@options)
-        if processor.valid?
-          queue(processor)
-        else
-          logger.info("Skip #{doc.name} => #{processor.reason}")
-        end
-      end
+    def process(**options)
+      render_option(**options)
+      return if targets.nil?
 
-      def process
-        @queue.each do |processor|
-          processor.process(**@options)
-        end
+      targets.split(',').each do |option|
+        render_option(version: option.split(','), **options)
       end
     end
   end
@@ -171,15 +244,15 @@ module MakePDF
   ::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}")
+    @pdf_site = MakePDF::MakePDFSite.new(site)
+    @pdf_site.logger.debug("site :after_init #{@pdf_site}")
   end
 
   ::Jekyll::Hooks.register [:pages, :documents, :posts], :post_write do |doc|
-    @@site << doc
+    @pdf_site << doc
   end
 
-  ::Jekyll::Hooks.register [:site], :post_write do |site|
-    @@site.process
+  ::Jekyll::Hooks.register [:site], :post_write do
+    @pdf_site.process
   end
 end

data/lib/make_pdf.rb

@@ -3,6 +3,8 @@
 require 'fileutils'
 require 'path_of'
 
+require_relative "./pdf_logger.rb"
+
 module MakePDF
   module PathManip
 
@@ -11,69 +13,16 @@ module MakePDF
     end
   end
 
-  class Logger
-    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
-
-    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(input_base_url:, output_base_path:, input_scheme: "file", input_host: nil, logger: Logger.new() ,**options)
+    def initialize(input_base_url:, output_base_path:, output_name: nil, input_scheme: "file", input_host: nil, logger: PdfLogger.new(self.class.name) ,**options)
       @logger = logger
       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: })
-
+      @options = options.merge({ input_base_url:, output_base_path:, input_scheme:, input_host:, output_name: output_name || make_pdf_filename(input_base_url) })
     end
-    
+ 
     def make_relative_file(file, input_location:, **options)
       path_of(file).relative_path_from(path_of(input_location))
     end
@@ -89,20 +38,22 @@ module MakePDF
       end
     end
 
-    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
+    def make_pdf_filename(file, output_base_path:, input_location:, output_name:, output_dir:, **options)
+      base_path = path_of(output_base_path)
+      filepath = make_relative_file(path_of(file).dirname, input_location:)
+      result = base_path / relative_path_of(output_dir) / filepath / output_name
       @logger.verbose("make_pdf_filename(#{file}, #{output_base_path}) → base_path: #{base_path}, filepath: #{filepath} ⇒ #{result}")
       result
     end
 
-    def make_output_filename(file, input_location:, output_base_path:, output_dir: ".", **options)
+    def make_output_filename(file, input_location:, output_base_path:, output_name:, 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) 
+      filename = make_pdf_filename(file, output_base_path:, output_dir:, output_name:, 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)
+      
+      FileUtils::mkdir_p(output.dirname) unless (output.dirname.directory?)
+
       @logger.debug("filename: #{filename} ⇒ #{output}")
       output
     end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: make_pdf-jekyll
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Victor Bogado da Silva Lins
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-03 00:00:00.000000000 Z
+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  '
@@ -21,11 +20,10 @@ files:
 - lib/make_pdf/command_based.rb
 - lib/make_pdf/firefox.rb
 - lib/make_pdf/jekyll.rb
-homepage: https://rubygems.org/gems/make_pdf-jekyll
+homepage: https://github.com/bogado/make_pdf-jekyll
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -33,15 +31,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.25
-signing_key:
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Create PDF along side of HTML files for site.
 test_files: []