asciidoctor-latexmath 1.0.0.pre.dev.1 → 2.0.0.alpha.1

data/lib/asciidoctor/latexmath/rendering/pdf_to_png_renderer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Shuai Zhang
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later WITH LGPL-3.0-linking-exception
+
+require "fileutils"
+
+require_relative "renderer"
+require_relative "tool_detector"
+require_relative "../command_runner"
+require_relative "../errors"
+
+module Asciidoctor
+  module Latexmath
+    module Rendering
+      class PdfToPngRenderer < Renderer
+        def name
+          "pdf_to_png"
+        end
+
+        def render(request, context)
+          previous = context.respond_to?(:[]) ? context[:previous_output] : nil
+          return previous if request.format != :png && previous
+
+          pdf_path = select_pdf_path(previous, context)
+          return pdf_path unless request.format == :png
+
+          record = context.fetch(:tool_detector).ensure_png_tool!
+
+          artifact_dir = context.fetch(:artifact_dir)
+          FileUtils.mkdir_p(artifact_dir)
+          output_path = File.join(artifact_dir, "#{context.fetch(:artifact_basename)}.png")
+
+          command = build_command(record, pdf_path, output_path, request)
+          result = CommandRunner.run(command, timeout: request.timeout, chdir: File.dirname(pdf_path), env: {})
+          unless result.exit_status.zero?
+            message = <<~MSG.strip
+              #{record.id} exited with status #{result.exit_status}
+              command: #{command.join(" ")}
+              stdout: #{truncate_output(result.stdout)}
+              stderr: #{truncate_output(result.stderr)}
+            MSG
+            raise StageFailureError, message
+          end
+
+          unless File.exist?(output_path)
+            fallback = detect_fallback_png(output_path)
+            if fallback
+              FileUtils.mv(fallback, output_path)
+            else
+              raise StageFailureError, "PNG conversion did not produce expected output: #{output_path}"
+            end
+          end
+
+          output_path
+        end
+
+        private
+
+        def select_pdf_path(previous, context)
+          if previous && File.extname(previous.to_s).casecmp(".pdf").zero?
+            previous
+          else
+            File.join(context.fetch(:tmp_dir), "#{context.fetch(:artifact_basename)}.pdf")
+          end
+        end
+
+        def build_command(record, pdf_path, output_path, request)
+          case record.id
+          when :pdftoppm
+            prefix = output_path.sub(/\.png\z/, "")
+            [record.path, "-png", "-singlefile", "-r", effective_ppi(request).to_s, pdf_path, prefix]
+          when :magick
+            [record.path, "-density", effective_ppi(request).to_s, pdf_path, "-quality", "90", output_path]
+          when :gs
+            [record.path, "-dSAFER", "-dBATCH", "-dNOPAUSE", "-sDEVICE=pngalpha", "-r#{effective_ppi(request)}", "-sOutputFile=#{output_path}", pdf_path]
+          else
+            [record.path, pdf_path, output_path]
+          end
+        end
+
+        def effective_ppi(request)
+          request.ppi || 300
+        end
+
+        def detect_fallback_png(expected_path)
+          base = expected_path.sub(/\.png\z/, "")
+          candidate = "#{base}-1.png"
+          return candidate if File.exist?(candidate)
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/latexmath/rendering/pdf_to_svg_renderer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Shuai Zhang
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later WITH LGPL-3.0-linking-exception
+
+require "fileutils"
+
+require_relative "renderer"
+require_relative "tool_detector"
+require_relative "../command_runner"
+require_relative "../errors"
+
+module Asciidoctor
+  module Latexmath
+    module Rendering
+      class PdfToSvgRenderer < Renderer
+        def name
+          "pdf_to_svg"
+        end
+
+        def render(request, context)
+          previous = context.respond_to?(:[]) ? context[:previous_output] : nil
+          pdf_path = previous || pdf_path_for(context)
+          return previous if request.format != :svg && previous
+          return pdf_path unless request.format == :svg
+
+          # `ensure_svg_tool!` raises MissingToolError when no converter is available;
+          # allow it to bubble so upstream handling can surface detailed hints.
+          record = context.fetch(:tool_detector).ensure_svg_tool!
+          artifact_dir = context.fetch(:artifact_dir)
+          FileUtils.mkdir_p(artifact_dir)
+          output_path = File.join(artifact_dir, "#{context.fetch(:artifact_basename)}.svg")
+
+          command = build_command(record, pdf_path, output_path)
+          result = CommandRunner.run(command, timeout: request.timeout, chdir: File.dirname(pdf_path), env: {})
+          unless result.exit_status.zero?
+            message = <<~MSG.strip
+              #{record.id} exited with status #{result.exit_status}
+              command: #{command.join(" ")}
+              stdout: #{truncate_output(result.stdout)}
+              stderr: #{truncate_output(result.stderr)}
+            MSG
+            raise StageFailureError, message
+          end
+
+          unless File.exist?(output_path)
+            fallback = detect_fallback_svg(output_path)
+            if fallback
+              FileUtils.mv(fallback, output_path)
+            else
+              raise StageFailureError, "SVG conversion did not produce expected output: #{output_path}"
+            end
+          end
+
+          output_path
+        end
+
+        private
+
+        def pdf_path_for(context)
+          File.join(context.fetch(:tmp_dir), "#{context.fetch(:artifact_basename)}.pdf")
+        end
+
+        def build_command(record, pdf_path, output_path)
+          case record.id
+          when :dvisvgm
+            [record.path, "--pdf", "--page=1", "-n", "-o", output_path, pdf_path]
+          else
+            [record.path, pdf_path, output_path]
+          end
+        end
+
+        def detect_fallback_svg(expected_path)
+          base = expected_path.sub(/\.svg\z/, "")
+          candidate = "#{base}-1.svg"
+          return candidate if File.exist?(candidate)
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/latexmath/rendering/pdflatex_renderer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Shuai Zhang
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later WITH LGPL-3.0-linking-exception
+
+require "fileutils"
+require "shellwords"
+
+require_relative "renderer"
+require_relative "../command_runner"
+require_relative "../errors"
+
+module Asciidoctor
+  module Latexmath
+    module Rendering
+      class PdflatexRenderer < Renderer
+        DEFAULT_FLAGS = ["-interaction=nonstopmode", "-halt-on-error", "-file-line-error"].freeze
+        SECURE_FLAG = "-no-shell-escape"
+        DISALLOWED_FLAGS = %w[-shell-escape --shell-escape -enable-write18 --enable-write18].freeze
+
+        def name
+          "pdflatex"
+        end
+
+        def render(request, context)
+          tmp_dir = context.fetch(:tmp_dir)
+          FileUtils.mkdir_p(tmp_dir)
+
+          tex_path = prepare_tex_source(context.fetch(:tex_artifact_path), tmp_dir, context.fetch(:artifact_basename))
+          command = build_command(request, tex_path, tmp_dir)
+
+          result = CommandRunner.run(command, timeout: request.timeout, chdir: tmp_dir, env: sanitized_env)
+          unless result.exit_status.zero?
+            message = <<~MSG.strip
+              pdflatex exited with status #{result.exit_status}
+              command: #{command.join(" ")}
+              stdout: #{truncate_output(result.stdout)}
+              stderr: #{truncate_output(result.stderr)}
+            MSG
+            raise StageFailureError, message
+          end
+
+          pdf_path = pdf_path_for(context)
+          unless File.exist?(pdf_path)
+            raise StageFailureError, "pdflatex did not produce expected output: #{pdf_path}"
+          end
+
+          pdf_path
+        rescue RenderTimeoutError
+          raise
+        rescue => error
+          raise StageFailureError, error.message
+        end
+
+        private
+
+        def pdf_path_for(context)
+          File.join(context.fetch(:tmp_dir), "#{context.fetch(:artifact_basename)}.pdf")
+        end
+
+        def prepare_tex_source(artifact_path, tmp_dir, basename)
+          filename = "#{basename}.tex"
+          destination = File.join(tmp_dir, filename)
+          FileUtils.cp(artifact_path, destination)
+          destination
+        end
+
+        def build_command(request, tex_path, tmp_dir)
+          tokens = Shellwords.shellsplit(request.engine.to_s)
+          raise StageFailureError, "pdflatex executable not specified" if tokens.empty?
+
+          executable = tokens.shift
+          engine = identify_engine(executable)
+          sanitized_flags = tokens.reject { |flag| disallowed_flag?(flag) }
+
+          if %i[pdflatex xelatex lualatex].include?(engine)
+            DEFAULT_FLAGS.each do |flag|
+              sanitized_flags.reject! { |existing| equivalent_flag?(existing, flag) }
+              sanitized_flags << flag
+            end
+
+            sanitized_flags.reject! { |existing| equivalent_flag?(existing, SECURE_FLAG) }
+            sanitized_flags << SECURE_FLAG
+
+            sanitized_flags = remove_output_directory_flags(sanitized_flags)
+            sanitized_flags << "-output-directory" << tmp_dir
+          elsif engine == :tectonic
+            sanitized_flags = remove_outdir_flags(sanitized_flags)
+            sanitized_flags << "--outdir" << tmp_dir
+          else
+            sanitized_flags = remove_output_directory_flags(sanitized_flags)
+            sanitized_flags << "-output-directory" << tmp_dir
+          end
+
+          [executable, *sanitized_flags, tex_path]
+        end
+
+        def sanitized_env
+          {
+            "openout_any" => "p",
+            "shell_escape" => "f"
+          }
+        end
+
+        def identify_engine(executable)
+          File.basename(executable.to_s).downcase.gsub(/[^a-z0-9]+/, "_").to_sym
+        end
+
+        def disallowed_flag?(flag)
+          base = flag.split("=").first
+          DISALLOWED_FLAGS.include?(base)
+        end
+
+        def equivalent_flag?(existing, desired)
+          base_existing = existing.split("=").first
+          base_desired = desired.split("=").first
+          base_existing == base_desired
+        end
+
+        def remove_output_directory_flags(flags)
+          result = []
+          skip_next = false
+
+          flags.each do |flag|
+            if skip_next
+              skip_next = false
+              next
+            end
+
+            base = flag.split("=").first
+            if base == "-output-directory"
+              skip_next = !flag.include?("=")
+              next
+            end
+
+            result << flag
+          end
+
+          result
+        end
+
+        def remove_outdir_flags(flags)
+          result = []
+          skip_next = false
+
+          flags.each do |flag|
+            if skip_next
+              skip_next = false
+              next
+            end
+
+            if flag.start_with?("--outdir")
+              skip_next = !flag.include?("=")
+              next
+            end
+
+            result << flag
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/latexmath/rendering/pipeline.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Shuai Zhang
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later WITH LGPL-3.0-linking-exception
+
+require_relative "renderer"
+
+module Asciidoctor
+  module Latexmath
+    module Rendering
+      class Pipeline
+        DEFAULT_STAGE_IDENTIFIERS = %i[pdflatex pdf_to_svg pdf_to_png].freeze
+
+        def self.default_stage_identifiers
+          DEFAULT_STAGE_IDENTIFIERS
+        end
+
+        def self.signature
+          DEFAULT_STAGE_IDENTIFIERS.join("|")
+        end
+
+        def initialize(stages)
+          @stages = stages
+        end
+
+        def execute(request, context)
+          current_output = nil
+
+          stages.each do |stage|
+            stage_context = enrich_context(context, current_output)
+            current_output = stage.render(request, stage_context)
+          end
+
+          current_output
+        end
+
+        private
+
+        attr_reader :stages
+
+        def enrich_context(context, previous_output)
+          return context if previous_output.nil?
+
+          if context.respond_to?(:merge)
+            context.merge(previous_output: previous_output)
+          elsif context.respond_to?(:dup) && context.respond_to?(:[]=)
+            duplicated = context.dup
+            duplicated[:previous_output] = previous_output
+            duplicated
+          else
+            context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/latexmath/rendering/renderer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Shuai Zhang
+#
+# SPDX-License-Identifier: LGPL-3.0-or-later WITH LGPL-3.0-linking-exception
+
+module Asciidoctor
+  module Latexmath
+    module Rendering
+      RendererResult = Struct.new(:output_path, :format, :intermediate, keyword_init: true)
+
+      class Renderer
+        def name
+          raise NotImplementedError, "Renderer subclasses must implement #name"
+        end
+
+        def render(_request, _context)
+          raise NotImplementedError, "Renderer subclasses must implement #render"
+        end
+
+        private
+
+        def truncate_output(output, limit = 500)
+          return "" unless output
+
+          return output if output.length <= limit
+
+          "#{output[0, limit]}..."
+        end
+      end
+    end
+  end
+end