sevgi-sundries 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20ba96c5308412cca2773c3678698968da83f06814ccdcd9b2d64c9ee522312c
-  data.tar.gz: 52b7e80ff6e5828ca83359eeeca6e593440f1dcd74943142987a1a7f149a5a95
+  metadata.gz: 31d7fd62cc7b0a3897e7a33e780d9ee367e1e782e5022eb5caabacd87633f98c
+  data.tar.gz: c639aa1e07d51c657d8b97400bf9a0696d60a697e87bb7eca94db5d7be5a9b08
 SHA512:
-  metadata.gz: 4a899ba87fcb53cd0652e27b587ecfe2ec5d8b184e23c27f114ae08b001aa30b3f9d06497ff921738c8fe7482e212aed5bd0cef71f9e221e9169e855c43faa99
-  data.tar.gz: 218c824c2748b155e8d2005df3e8176a6de4b9e80780cba56659ddac4987481d42c23e34b23b4c040d5f5a68d946436ae91640f43d68b94d3f5f841afd9273e8
+  metadata.gz: 4dad57c233fc530511b8385d3aedac7a8884957ca57472b56befcbd19561c193f9001c1c26442d99ef43e60ae4e452b2da0a2a27f1ef42a3b6f2f2a15201d533
+  data.tar.gz: 9d49982dabad9bb3cce57b38fa3e8bc229ce2b105671505e0a10dfe32d6fbe7c7cf0cad5e7a85d23b9d301b6981b409e49d7e039d83f4614dd9bc593ba6dcda3

data/CHANGELOG.md

@@ -3,6 +3,26 @@
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## Unreleased
+
+## 1.1.0 - 2026-10-29
+
+### Added
+
+- `Classes` returns an element's distinct CSS class names without changing the element; `Classify` shares its attribute normalization.
+- Generic document-local Style declarations with `Target`, `Param`, `Group`, and `Profiles`, and optional prepared PDF export through the native Mainz CLI.
+- Backend-independent `fallback: false` for export failures and `F.executable` for executable path lookup.
+- `F.path` for path validation and expansion, and `F.output_path` for default output names and directory targets.
+
+### Changed
+
+- Moved Graphics XML validation into auxiliary helpers and kept built-in paper dimensions in `Paper`.
+- Shared path validation between Graphics writers and Sundries exports while preserving output paths and error messages.
+
+### Fixed
+
+- Stamp code placeholders in nested and shared PDF Forms, with cycle-safe resource traversal.
+
 ## 1.0.0 - 2026-09-16
 
 ### Added

data/README.md

@@ -28,6 +28,41 @@ grid.canvas.margin.to_a # => [5.0, 5.0, 5.0, 5.0]
 Rulers, grids, and tiles are inspectable Ruby values. They create no SVG elements by themselves. Pass their geometry
 to Sevgi Graphics when the document needs it.
 
+## Prepared PDF export
+
+Sevgi uses the native Mainz CLI for SVG sources with a Style declaration.
+Mainz receives private temporary files through argument arrays and publishes one prepared PDF.
+Successful preparation replaces the destination atomically.
+Parallel calls use separate temporary directories and share no producer state.
+
+```ruby
+require "sevgi/sundries"
+
+Sevgi::Sundries::Export.call(svg, "drawing.pdf", style: declaration)
+Sevgi::Sundries::Export.call(svg, "prepared.pdf", style: declaration, fallback: false)
+Sevgi::Sundries::Mainz.produce(svg, "prepared.pdf", declaration: declaration)
+Sevgi::Sundries::Mainz.available?
+```
+
+`declaration` is a JSON-compatible Hash. `drawing.Style` returns its deeply frozen Hash representation.
+The default `fallback: true` warns and uses ordinary PDF export if Mainz cannot prepare the document.
+`fallback: false` raises `Sevgi::Sundries::Mainz::Error` if preparation fails. An unstyled document uses ordinary export.
+`Mainz.produce` always requires preparation and uses the same export validation.
+Invalid arguments and filesystem failures remain errors in both modes.
+Interrupts cancel export without fallback.
+CSS insertion and the source callback run once, including after a fallback.
+
+Mainz is optional. Install its native `mainz` executable on `PATH` to enable preparation.
+Install [Mainz 1.0.0](https://github.com/roktas/mainz/releases/tag/v1.0.0) through Homebrew:
+
+```sh
+brew install roktas/tap/mainz
+```
+
+Prepared export invokes the CLI without the `cairo`, `rsvg2`, and `hexapdf` Ruby gems.
+Ordinary PDF/PNG export and PDF stamping retain their optional Ruby dependencies.
+`Mainz.fingerprint` returns the executable digest and native dependency report for output caches, or nil when Mainz is absent.
+
 ## Ruby compatibility
 
 Requires Ruby 3.4.0 or newer. CI verifies the current Ruby 3.4 release and the development Ruby from `.ruby-version`.
@@ -37,7 +72,9 @@ Requires Ruby 3.4.0 or newer. CI verifies the current Ruby 3.4 release and the d
 Basic ruler, grid, and tile helpers need only Ruby dependencies. Installing `sevgi-sundries` does not install native
 export gems.
 
-PDF/PNG export helpers load the optional Ruby gems `cairo`, `rsvg2`, and `hexapdf` only when export is used. Install
+The `a5_on_a4` helpers require the `pdfcpu` command. They use its built-in defaults without personal pdfcpu configuration.
+
+Ordinary PDF/PNG export helpers load the optional Ruby gems `cairo`, `rsvg2`, and `hexapdf` only when export is used. Install
 their system libraries and gems separately:
 
 ```sh

data/lib/sevgi/sundries/export/input.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Sevgi
+  module Sundries
+    module Export
+      # Validated inputs shared by ordinary and prepared export.
+      # @api private
+      class Input
+        attr_reader :dimensions, :fallback, :style, :svg
+
+        def initialize(svg, options, &block)
+          @fallback = options.fetch(:fallback)
+          ArgumentError.("Export fallback must be true or false") unless [true, false].any? { it.equal?(fallback) }
+          @dimensions = %i[width height dpi].to_h do |key|
+            [key, dimension(options[key], key.to_s, optional: key != :dpi)]
+          end
+          @style = declaration(options[:style])
+          @svg = source(svg, options[:css], &block).dup.freeze
+        end
+
+        private
+
+        def declaration(value)
+          return if value.nil?
+          ArgumentError.("Export Style must be a Hash") unless value.is_a?(::Hash)
+          JSON.generate(value, strict: true, max_nesting: 32).freeze
+        rescue JSON::JSONError => e
+          ArgumentError.("Invalid Style JSON: #{e.message}")
+        end
+
+        def source(svg, css)
+          ArgumentError.("SVG content must be a String") unless svg.is_a?(String)
+          css = stylesheet(css)
+          svg = Export.send(:styled, svg, css) if css
+          svg = yield(svg) if block_given?
+          ArgumentError.("SVG content must be a String") unless svg.is_a?(String)
+          svg
+        end
+
+        def stylesheet(css)
+          return if css.nil?
+          ArgumentError.("Export CSS must be a String") unless css.is_a?(String)
+          ArgumentError.("Export CSS must be valid text") unless css.valid_encoding?
+          css unless css.strip.empty?
+        end
+
+        # Numeric coercion and finite positive admission are one boundary check.
+        # rubocop:disable-next Metrics/CyclomaticComplexity
+        def dimension(value, field, optional: true)
+          return if value.nil? && optional
+          ExportError.(dimension_error(field)) unless value.is_a?(::Numeric)
+          number = begin
+            value.to_f
+          rescue ::StandardError => e
+            ExportError.(dimension_error(field, e.message))
+          end
+          ExportError.(dimension_error(field)) unless number.is_a?(::Float) && number.finite? && number.positive?
+          number
+        end
+
+        def dimension_error(field, detail = nil)
+          message = [
+            (%w[width height].include?(field) ? "Invalid export dimensions" : "Invalid export #{field}"),
+            detail
+          ]
+          message.compact.join(": ")
+        end
+      end
+
+      private_constant :Input
+    end
+  end
+end

data/lib/sevgi/sundries/export/native.rb

@@ -13,43 +13,13 @@ module Sevgi
   module Sundries
     module Export
       %i[
-        call
         stamp
         stamp!
       ].each { remove_method(it) if method_defined?(it) }
 
-      # Exports SVG source to a PDF or PNG file using librsvg and Cairo.
-      # @param svg [String] SVG source content
-      # Relative paths are expanded, missing parent directories are created after all render inputs validate, and an
-      # existing output file is replaced. Directory paths are not expanded to a default file name.
-      # @param output [String, #to_path] output file path
-      # @param format [Symbol, String, nil] explicit output format, or nil to infer from output extension
-      # @param width [Numeric, nil] finite positive target width in output pixels for PNG, or CSS pixels before PDF point conversion
-      # @param height [Numeric, nil] finite positive target height in output pixels for PNG, or CSS pixels before PDF point conversion
-      # @param dpi [Numeric] finite positive CSS pixel density. Omission uses {DEFAULT_DPI}, but explicit nil is invalid
-      # @param css [String, nil] CSS inserted before the closing svg tag before rendering
-      # @yield [svg] optional source transformation applied before rendering
-      # @yieldparam svg [String] SVG source after optional CSS injection
-      # @yieldreturn [String] SVG source to render
-      # @return [String] expanded output path
-      # @raise [Sevgi::ArgumentError] when output is blank, invalid, or a directory, or CSS/transformed SVG has an
-      #   invalid type
-      # @raise [Sevgi::Sundries::Export::ExportError] when format, numeric options, CSS insertion, SVG parsing, SVG dimensions, or render dimensions are invalid
-      # @raise [SystemCallError] when the output directory or file cannot be created or written
-      def call(svg, output, format: nil, width: nil, height: nil, dpi: DEFAULT_DPI, css: nil, &block)
-        ArgumentError.("SVG content must be a String") unless svg.is_a?(String)
-        output = output_path(output)
-        format = format_for(format, output)
-        width = dimension(width, "width")
-        height = dimension(height, "height")
-        dpi = dimension(dpi, "dpi", optional: false)
-        ArgumentError.("Export CSS must be a String") unless css.nil? || css.is_a?(String)
-        ArgumentError.("Export CSS must be valid text") if css && !css.valid_encoding?
-
-        svg = styled(svg, css) if css && !css.strip.empty?
-        svg = block.call(svg) if block
-        ArgumentError.("SVG content must be a String") unless svg.is_a?(String)
-
+      # Renders validated, transformed SVG through librsvg and Cairo.
+      # @api private
+      def render(svg, output, format:, width:, height:, dpi:)
         renderer = Renderer.method(format)
 
         begin
@@ -82,6 +52,30 @@ module Sevgi
 
         output
       end
+      private :render
+
+      # @api private
+      def stamp_forms(document, stamp:, placeholder:)
+        pending = document.pages.flat_map { |page| page[:Resources][:XObject]&.each&.map { |_name, value| value } || [] }
+        seen = {}
+        replacements = 0
+        until pending.empty?
+          form = pending.pop
+          next unless form[:Subtype] == :Form
+          identity = [form.oid, form.gen]
+          next if seen[identity]
+          seen[identity] = true
+          objects = form[:Resources]&.[](:XObject)
+          pending.concat(objects ? objects.each.map { |_name, value| value } : [])
+          data, count = stamp_stream(form.stream, stamp:, placeholder:)
+          next if count.zero?
+          replacements += count
+          form.stream = data
+          form.set_filter(:FlateDecode)
+        end
+        replacements
+      end
+      private :stamp_forms
 
       # Replaces exact placeholder text objects in PDF streams.
       # The placeholder must appear as a PDF literal string in a white text object matching the export stamp pattern.
@@ -107,6 +101,7 @@ module Sevgi
           doc.deref(page[:Contents]).set_filter(:FlateDecode)
         end
 
+        replacements += stamp_forms(doc, stamp:, placeholder:)
         doc.write(outfile, optimize: true) if replacements.positive?
         replacements.positive?
       rescue HexaPDF::Error, ::SystemCallError => e
@@ -317,45 +312,6 @@ module Sevgi
       class << self
         private
 
-        def output_path(output)
-          ArgumentError.("Export output must be provided") if output.nil?
-
-          path = output.respond_to?(:to_path) ? output.to_path : output
-          ArgumentError.("Export output must be a String or path-like object") unless path.is_a?(::String)
-          ArgumentError.("Export output must be provided") if path.strip.empty?
-
-          path = ::File.expand_path(path)
-          ArgumentError.("Export output must name a file") if ::File.directory?(path)
-          path
-        rescue ::StandardError => e
-          raise if e.is_a?(::Sevgi::ArgumentError)
-
-          ArgumentError.("Export output must be a String or path-like object: #{e.message}")
-        end
-
-        def dimension(value, field, optional: true)
-          return if value.nil? && optional
-          ExportError.(dimension_error(field)) unless value.is_a?(::Numeric)
-
-          number = begin
-            value.to_f
-          rescue ::StandardError => e
-            ExportError.(dimension_error(field, e.message))
-          end
-
-          ExportError.(dimension_error(field)) unless number.is_a?(::Float) && number.finite? && number.positive?
-
-          number
-        end
-
-        def dimension_error(field, detail = nil)
-          message = [
-            (%w[width height].include?(field) ? "Invalid export dimensions" : "Invalid export #{field}"),
-            detail
-          ]
-          message.compact.join(": ")
-        end
-
         def intrinsic_size(handle)
           if handle.respond_to?(:intrinsic_dimensions)
             has_width, width, has_height, height, has_viewbox, viewbox = handle.intrinsic_dimensions

data/lib/sevgi/sundries/export/system.rb

@@ -13,7 +13,9 @@ module Sevgi
       # @raise [Sevgi::Error] when pdfcpu is missing or the command fails
       # @raise [Errno::ENOENT] when the executable cannot be spawned
       # @see https://pdfcpu.io/ pdfcpu
-      def a5_on_a4(infile, outfile) = F.sh!("pdfcpu", "nup", "--", "form:A4L, border:off", outfile, "2", infile)
+      def a5_on_a4(infile, outfile)
+        F.sh!("pdfcpu", "--conf", "disable", "nup", "--", "form:A4L, border:off", outfile, "2", infile)
+      end
 
       # Replaces a PDF file with an A5-on-A4 layout generated by pdfcpu.
       # @param infile [String] PDF file path to modify

data/lib/sevgi/sundries/export.rb

@@ -3,6 +3,8 @@
 require "sevgi/function"
 
 require_relative "export/system"
+require_relative "export/input"
+require_relative "mainz"
 
 module Sevgi
   module Sundries
@@ -16,7 +18,7 @@ module Sevgi
     # Export-only CSS is a last-minute adjustment, not a replacement for document styles or validation. Insertion
     # requires well-formed SVG ending in an unprefixed `</svg>` followed only by XML whitespace. Self-closing roots,
     # prefixed roots, and trailing comments are unsupported with CSS. CSS is XML-escaped but not parsed or validated.
-    # The native source callback runs after insertion and before conversion. External backends have no such callback.
+    # The source callback runs after insertion and before ordinary or prepared conversion.
     #
     # @example Export SVG source to a sized PNG
     #   svg = Sevgi::Graphics.SVG(width: 10, height: 10) { circle cx: 5, cy: 5, r: 4 }.Render
@@ -51,27 +53,40 @@ module Sevgi
 
       private_constant :NATIVE_COMPONENTS
 
-      # @overload call(svg, output, format: nil, width: nil, height: nil, dpi: DEFAULT_DPI, css: nil)
-      #   Exports SVG source to a PDF or PNG file using the optional native export gems.
-      #   @param svg [String] SVG source content
-      #   Relative paths are expanded, missing parent directories are created after all render inputs validate, and an
-      #   existing output file is replaced. Directory paths are not expanded to a default file name.
-      #   @param output [String, #to_path] output file path
-      #   @param format [Symbol, String, nil] explicit output format, or nil to infer from output extension
-      #   @param width [Numeric, nil] target width in output pixels for PNG, or CSS pixels before PDF point conversion
-      #   @param height [Numeric, nil] target height in output pixels for PNG, or CSS pixels before PDF point conversion
-      #   @param dpi [Numeric] finite positive CSS pixel density. Omission uses {DEFAULT_DPI}, but explicit nil is invalid
-      #   @param css [String, nil] CSS inserted before the closing svg tag before rendering
-      #   @yield [svg] optional source transformation applied before rendering
-      #   @yieldparam svg [String] SVG source after optional CSS injection
-      #   @yieldreturn [String] SVG source to render
-      #   @return [String] expanded output path
-      #   @raise [Sevgi::ArgumentError] when SVG content is not a string or output is blank, invalid, or a directory
-      #   @raise [Sevgi::MissingComponentError] when cairo, hexapdf, or rsvg2 is unavailable
-      #   @raise [Sevgi::Sundries::Export::ExportError] when format, CSS insertion, SVG parsing, SVG dimensions, or
-      #     render dimensions are invalid
-      #   @raise [SystemCallError] when the output directory or file cannot be created or written
-      def call(*args, **kwargs, &block) = native!.call(*args, **kwargs, &block)
+      # rubocop:disable Metrics/ParameterLists
+
+      # Exports SVG source through ordinary rendering or optional Mainz preparation.
+      # Style selects Mainz automatically for PDF output. Unstyled documents use ordinary export.
+      # Fallback warns and uses ordinary PDF export after a preparation failure.
+      # CSS and the source callback run once before either backend receives the source.
+      # @param svg [String] SVG source content
+      # @param output [String, #to_path] output file path
+      # @param format [Symbol, String, nil] explicit output format, or nil to infer from output extension
+      # @param width [Numeric, nil] target width in output pixels for PNG, or CSS pixels before PDF point conversion
+      # @param height [Numeric, nil] target height in output pixels for PNG, or CSS pixels before PDF point conversion
+      # @param dpi [Numeric] finite positive CSS pixel density. Omission uses {DEFAULT_DPI}, but explicit nil is invalid
+      # @param css [String, nil] CSS inserted before the closing svg tag before rendering
+      # @param style [Hash, nil] optional JSON authoring declaration
+      # @param fallback [Boolean] permit ordinary export after prepared export fails
+      # @yield [svg] optional source transformation before rendering
+      # @yieldparam svg [String] SVG source after optional CSS insertion
+      # @yieldreturn [String] SVG source to render
+      # @return [String] expanded output path
+      # @raise [Sevgi::ArgumentError] when the source, path, declaration, or fallback value is invalid
+      # @raise [Sevgi::MissingComponentError] when ordinary export requires unavailable native gems
+      # @raise [Sevgi::Sundries::Export::ExportError] when format, dimensions, CSS insertion, or ordinary rendering fails
+      # @raise [Sevgi::Sundries::Mainz::Error] when preparation fails and fallback is false
+      # @raise [SystemCallError] when the output directory or file cannot be written
+      def call(svg, output, format: nil, width: nil, height: nil, dpi: DEFAULT_DPI, css: nil,
+        style: nil, fallback: true, &block)
+        output = output_path(output)
+        format = format_for(format, output)
+        input = Input.new(svg, {width:, height:, dpi:, css:, style:, fallback:}, &block)
+        return output if format == :pdf && prepared(input, output)
+        native!
+        render(input.svg, output, format:, **input.dimensions)
+      end
+      # rubocop:enable Metrics/ParameterLists
 
       def format_for(format, output)
         if format
@@ -135,6 +150,26 @@ module Sevgi
       class << self
         private
 
+        def prepared(input, output)
+          return false unless input.style
+          Mainz.send(:write, input, output)
+          true
+        rescue Mainz::Error => e
+          raise unless input.fallback
+          warn("#{e.message}; exporting an ordinary PDF without editable styles")
+          false
+        end
+
+        def output_path(output)
+          ArgumentError.("Export output must be provided") if output.nil?
+          path = F.path(output, context: "Export output")
+          ArgumentError.("Export output must name a file") if ::File.directory?(path)
+          path
+        rescue ::StandardError => e
+          raise if e.is_a?(::Sevgi::ArgumentError)
+          ArgumentError.("Export output must be a String or path-like object: #{e.message}")
+        end
+
         def native!
           require_relative "export/native"
 

data/lib/sevgi/sundries/mainz.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "tmpdir"
+
+module Sevgi
+  module Sundries
+    # Optional CLI boundary for Mainz prepared PDF production.
+    module Mainz
+      COMMAND = "mainz"
+      private_constant :COMMAND
+
+      # A missing or unsuccessful Mainz producer.
+      Error = Class.new(::Sevgi::Error)
+
+      # Reports whether the Mainz executable is installed on PATH.
+      # @return [Boolean]
+      def available? = F.executable?(COMMAND)
+
+      # Returns the selected executable's content identity for output caches.
+      # PATH is resolved on each call. Absence returns nil.
+      # @return [Hash{String => Object}, nil] executable SHA-256 and native dependency report
+      # @raise [SystemCallError] when the executable cannot be read
+      # @raise [Sevgi::Sundries::Mainz::Error] when the version command fails or its report is invalid
+      def fingerprint
+        path = F.executable(COMMAND)
+        return unless path
+        process = run(path, "--version")
+        report = JSON.parse(process.out)
+        Error.("Invalid Mainz version report") unless report.is_a?(Hash) && report["contract"] == 1
+        {"sha256" => Digest::SHA256.file(path).hexdigest, "runtime" => report}
+      rescue JSON::ParserError => e
+        Error.("Invalid Mainz version report: #{e.message}")
+      end
+
+      # Produces and atomically replaces one PDF through the native CLI.
+      # Input paths and output staging remain private to this call.
+      # @param svg [String] SVG source
+      # @param output [String, #to_path] destination path
+      # @param declaration [Hash] JSON authoring declaration
+      # @param options [Hash] ordinary export options
+      # @option options [Numeric, nil] :width output width in CSS pixels
+      # @option options [Numeric, nil] :height output height in CSS pixels
+      # @option options [Numeric] :dpi (96.0) positive CSS pixel density
+      # @option options [String, nil] :css export-only CSS
+      # @yield [svg] transforms the source once before production
+      # @yieldparam svg [String] SVG after optional CSS insertion
+      # @yieldreturn [String] source to render
+      # @return [String] expanded destination path
+      # @raise [Sevgi::ArgumentError] when the source, path, or declaration is invalid
+      # @raise [Sevgi::Sundries::Mainz::Error] when Mainz is missing or preparation fails
+      # @raise [SystemCallError] when staging or installation fails
+      def produce(svg, output, declaration:, **options, &block)
+        ArgumentError.("Mainz declaration must be a Hash") unless declaration.is_a?(::Hash)
+        unknown = options.keys - %i[css dpi height width]
+        ArgumentError.("Unknown Mainz option: #{unknown.first}") unless unknown.empty?
+        Export.call(svg, output, format: :pdf, style: declaration, fallback: false, **options, &block)
+      end
+
+      extend self
+
+      class << self
+        private
+
+        def write(input, output)
+          program = F.executable(COMMAND) || Error.("Mainz executable is unavailable")
+          parent = ::File.dirname(output)
+          parent = ::File.dirname(parent) until ::File.directory?(parent)
+          dimensions = input.dimensions.flat_map { |key, value| value.nil? ? [] : ["--#{key}", value.to_s] }
+          ::Dir.mktmpdir(".sevgi-mainz-", parent) do |directory|
+            result = prepare(program, directory, input.svg, input.style, dimensions)
+            install(result, output)
+          end
+          output
+        end
+
+        def prepare(program, directory, svg, declaration, dimensions)
+          source, definitions, result = %w[source.svg style.json output.pdf].map { ::File.join(directory, it) }
+          ::File.binwrite(source, svg)
+          ::File.write(definitions, declaration)
+          run(program, "produce", source, "--declaration", definitions, "--output", result, *dimensions)
+          result
+        end
+
+        def run(*arguments)
+          process = F.sh(*arguments)
+          raise ::Interrupt if Signal.list.values_at("INT", "TERM", "KILL").include?(process.signal) || process.exit_code == 130
+          Error.("Mainz preparation failed: #{process.err}") unless process.ok?
+          process
+        rescue Errno::ENOENT => e
+          Error.("Mainz executable is unavailable: #{e.message}")
+        end
+
+        def install(result, output)
+          unless ::File.file?(result) && !::File.symlink?(result) && ::File.size(result).positive?
+            Error.("Mainz produced no PDF")
+          end
+          ::FileUtils.mkdir_p(::File.dirname(output))
+          ::File.rename(result, output)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/sundries/version.rb

@@ -3,6 +3,6 @@
 module Sevgi
   module Sundries
     # Component version.
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sevgi-sundries
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Recai Oktaş
@@ -9,48 +9,62 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sevgi-function
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: sevgi-geometry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: sevgi-graphics
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.1.0
 description: Includes grid, ruler, tile, and optional PDF or PNG export support.
 email: roktas@gmail.com
 executables: []
@@ -62,9 +76,11 @@ files:
 - README.md
 - lib/sevgi/sundries.rb
 - lib/sevgi/sundries/export.rb
+- lib/sevgi/sundries/export/input.rb
 - lib/sevgi/sundries/export/native.rb
 - lib/sevgi/sundries/export/system.rb
 - lib/sevgi/sundries/grid.rb
+- lib/sevgi/sundries/mainz.rb
 - lib/sevgi/sundries/ruler.rb
 - lib/sevgi/sundries/tile.rb
 - lib/sevgi/sundries/version.rb