stacked-pdf-generator 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88f906f92904c70c05d8b8c7c17fffaa0c951461f79b23e226006d9a61e382b0
+  data.tar.gz: ca874b7ad695d4bbdaf04182b284a27ccea61b3928d3cec634c78e0cbc174972
+SHA512:
+  metadata.gz: c2647cb6ec1dab56a3bd668dc20975c313d47f3f9eab44129fb4e4406ddae4d57c1555bd02d2be7b28aec99215a246cb18cad0e530da26e8fb2a3c64632960ff
+  data.tar.gz: 95b862c750f88049f5f9213b36803971c2ddbe519199cc5cd833c353e83d72288aa90a9be9337ace3a7d6f5a346c1e37a233ad989014c43c4aa7acba8b137074

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jeremy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# Stacked PDF Generator
+
+A Ruby gem and CLI that wraps `pdfjam`, `pdfinfo`, and `podofocrop` to produce
+stack-cut friendly PDFs, relying on the `stacking-order` gem for page sequencing.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'stacked-pdf-generator'
+```
+
+Or install directly:
+
+```bash
+gem install stacked-pdf-generator
+```
+
+## Usage
+
+### Library
+
+```ruby
+require 'stacked_pdf_generator'
+
+result = StackedPdfGenerator.call(
+  input_path: 'input.pdf',
+  output_path: 'output.pdf',
+  rows: 7,
+  columns: 1,
+  paper_size: 'a4',
+  autoscale: 'pdfjam',
+  portrait: false,
+  sheet_margins: '10 10 10 10'
+)
+
+if result.success?
+  puts 'Generated successfully!'
+else
+  warn result.message
+end
+```
+
+### CLI
+
+```
+stacked-pdf-generator --input input.pdf --output output.pdf --rows 7 --columns 1 \
+  --paper-size a4 --autoscale pdfjam --portrait false --sheet-margins "10 10 10 10"
+```
+
+You can continue to pass `--pages-per-sheet N` for backwards compatibility; if
+rows/columns are omitted they fall back to `1 x N`.
+
+Run `stacked-pdf-generator --help` for the full list of options.
+
+## License
+
+MIT

data/exe/stacked-pdf-generator

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+
+begin
+  require 'stacked_pdf_generator'
+rescue LoadError
+  lib_path = File.expand_path('../lib', __dir__)
+  $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+  require 'stacked_pdf_generator'
+end
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: stacked-pdf-generator --input INPUT --output OUTPUT [options]'
+
+  opts.on('--input PATH', 'Input PDF path') { |value| options[:input_path] = value }
+  opts.on('--output PATH', 'Output PDF path') { |value| options[:output_path] = value }
+  opts.on('--pages-per-sheet N', Integer, 'Total pages per sheet (legacy single-dimension input)') do |value|
+    options[:pages_per_sheet] = value
+  end
+  opts.on('--rows N', Integer, 'Number of rows per sheet') { |value| options[:rows] = value }
+  opts.on('--columns N', Integer, 'Number of columns per sheet') { |value| options[:columns] = value }
+  opts.on('--paper-size SIZE', 'Paper size (a4 or a3)') { |value| options[:paper_size] = value }
+  opts.on('--autoscale MODE', 'Autoscale mode (pdfjam, none, podofo)') { |value| options[:autoscale] = value }
+  opts.on('--portrait BOOLEAN', 'Portrait layout (true/false)') { |value| options[:portrait] = value }
+  opts.on('--sheet-margins "L R T B"', 'Optional sheet margins in mm') { |value| options[:sheet_margins] = value }
+
+  opts.on('-v', '--version', 'Print version') do
+    puts StackedPdfGenerator::VERSION
+    exit 0
+  end
+
+  opts.on('-h', '--help', 'Show help') do
+    puts opts
+    exit 0
+  end
+end
+
+begin
+  parser.parse!(ARGV)
+rescue OptionParser::ParseError => e
+  warn e.message
+  warn parser
+  exit 1
+end
+
+required = %i[input_path output_path paper_size autoscale portrait]
+missing = required.reject { |key| options[key] }
+if missing.any?
+  warn "Missing required options: #{missing.join(', ')}"
+  warn parser
+  exit 1
+end
+
+if options[:pages_per_sheet].nil? && (options[:rows].nil? || options[:columns].nil?)
+  warn 'Specify either --pages-per-sheet or both --rows and --columns'
+  warn parser
+  exit 1
+end
+
+result = StackedPdfGenerator.call(
+  input_path: options[:input_path],
+  output_path: options[:output_path],
+  pages_per_sheet: options[:pages_per_sheet],
+  rows: options[:rows],
+  columns: options[:columns],
+  paper_size: options[:paper_size],
+  autoscale: options[:autoscale],
+  portrait: options[:portrait],
+  sheet_margins: options[:sheet_margins]
+)
+
+if result.success?
+  puts 'PDF generated successfully.'
+else
+  warn result.message
+  exit 1
+end

data/lib/stacked_pdf_generator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StackedPdfGenerator
+  VERSION = '1.0.0'
+end

data/lib/stacked_pdf_generator.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+require 'securerandom'
+require 'stacking_order'
+
+require_relative 'stacked_pdf_generator/version'
+
+# Provides library and CLI helpers for generating stack-cut friendly PDFs using
+# pdfjam/podofocrop tooling and stacking-order-based page sequencing.
+module StackedPdfGenerator
+  ProcessingError = Class.new(StandardError)
+
+  Result = Struct.new(:success?, :message, keyword_init: true)
+
+  module_function
+
+  def call(**kwargs)
+    Generator.new(**kwargs).call
+  end
+
+  # Performs the heavy lifting: validates inputs, shells out to pdfjam/podofocrop,
+  # and sequences pages via stacking-order to build the final PDF.
+  class Generator
+    attr_reader :input_path, :output_path, :paper_size, :autoscale, :portrait,
+                :sheet_margins_raw, :rows, :columns, :pages_per_sheet
+
+    def initialize(input_path:, output_path:, paper_size:, autoscale:, portrait:, rows: nil, columns: nil,
+                   pages_per_sheet: nil, sheet_margins: nil)
+      @input_path = input_path
+      @output_path = output_path
+      @paper_size = paper_size.to_s.upcase
+      @autoscale = autoscale.to_s
+      @portrait = boolean_cast(portrait)
+      @sheet_margins_raw = sheet_margins
+      @rows = rows.nil? ? nil : Integer(rows)
+      @columns = columns.nil? ? nil : Integer(columns)
+      @pages_per_sheet = pages_per_sheet.nil? ? nil : Integer(pages_per_sheet)
+      normalize_layout_dimensions!
+    end
+
+    def call
+      validate_arguments!
+      run_pdfjam
+      finalize_output
+      Result.new(success?: true, message: '')
+    rescue ProcessingError => e
+      Result.new(success?: false, message: e.message)
+    ensure
+      cleanup_tempfile
+    end
+
+    private
+
+    def validate_arguments!
+      raise ProcessingError, 'Missing input PDF' unless present?(input_path) && File.exist?(input_path)
+      raise ProcessingError, 'Missing output path' if blank?(output_path)
+      raise ProcessingError, 'pages_per_sheet must be positive' unless pages_per_sheet.positive?
+    end
+
+    def run_pdfjam
+      sequence = page_sequence
+      cmd = [
+        'pdfjam', input_path, sequence,
+        '-o', temp_output_path,
+        '--nup', "#{columns}x#{rows}",
+        '--paper', paper_size_option
+      ]
+
+      cmd.concat(%w[--noautoscale true]) if %w[none podofo].include?(autoscale)
+      cmd << '--landscape' unless portrait
+      cmd << '--quiet'
+
+      if sheet_margins_mm
+        margin_string = sheet_margins_mm.map { |value| format('%gmm', value) }.join(' ')
+        cmd.concat(['--trim', margin_string, '--clip', 'true'])
+      end
+
+      stdout, stderr, status = Open3.capture3(*cmd)
+      raise ProcessingError, format_failure('pdfjam', stdout, stderr) unless status.success?
+    end
+
+    def finalize_output
+      if autoscale == 'podofo'
+        stdout, stderr, status = Open3.capture3('podofocrop', temp_output_path, output_path)
+        raise ProcessingError, format_failure('podofocrop', stdout, stderr) unless status.success?
+
+        FileUtils.rm_f(temp_output_path)
+      else
+        FileUtils.mv(temp_output_path, output_path)
+      end
+    end
+
+    def cleanup_tempfile
+      FileUtils.rm_f(temp_output_path) if defined?(@temp_output_path) && File.exist?(@temp_output_path)
+    end
+
+    def temp_output_path
+      @temp_output_path ||= begin
+        dirname = File.dirname(output_path)
+        FileUtils.mkdir_p(dirname)
+        File.join(dirname, "stacked_tmp_#{SecureRandom.hex(6)}.pdf")
+      end
+    end
+
+    def format_failure(tool, stdout, stderr)
+      details = presence(stderr) || presence(stdout) || 'Unknown error'
+      "#{tool} failed: #{details.strip}"
+    end
+
+    def sheet_margins_mm
+      return @sheet_margins_mm if defined?(@sheet_margins_mm)
+      return (@sheet_margins_mm = nil) if blank?(sheet_margins_raw)
+
+      values = sheet_margins_raw.split.map do |value|
+        Float(value)
+      rescue ArgumentError
+        nil
+      end
+
+      @sheet_margins_mm = values.compact.length == 4 ? values.first(4) : nil
+    end
+
+    def paper_size_option
+      paper_size == 'A3' ? 'a3paper' : 'a4paper'
+    end
+
+    def page_sequence
+      total_pages = detect_page_count
+      order = StackingOrder.order(entries: total_pages, rows: rows, columns: columns)
+      cells_per_page = rows * columns
+
+      remainder = order.length % cells_per_page
+      order += [nil] * (cells_per_page - remainder) unless remainder.zero?
+
+      order.map { |value| value || '{}' }.join(',')
+    end
+
+    def detect_page_count
+      stdout, stderr, status = Open3.capture3('pdfinfo', input_path)
+      raise ProcessingError, format_failure('pdfinfo', stdout, stderr) unless status.success?
+
+      match = stdout.match(/Pages:\s+(\d+)/)
+      raise ProcessingError, 'Unable to determine page count' unless match
+
+      match[1].to_i
+    end
+
+    def normalize_layout_dimensions!
+      if rows && columns
+        ensure_positive_dimensions!
+        @pages_per_sheet ||= rows * columns
+      elsif pages_per_sheet
+        @rows ||= pages_per_sheet
+        @columns ||= 1
+        ensure_positive_dimensions!
+        @pages_per_sheet = rows * columns
+      else
+        raise ProcessingError, 'Provide either pages_per_sheet or both rows and columns'
+      end
+    end
+
+    def ensure_positive_dimensions!
+      raise ProcessingError, 'rows must be positive' unless rows.positive?
+      raise ProcessingError, 'columns must be positive' unless columns.positive?
+    end
+    def boolean_cast(value)
+      return value if value == true || value == false
+      return true if value.is_a?(Numeric) && value != 0
+      return false if value.is_a?(Numeric)
+
+      if value.is_a?(String)
+        stripped = value.strip.downcase
+        return true if %w[true t 1 yes y].include?(stripped)
+        return false if %w[false f 0 no n].include?(stripped)
+      end
+
+      !!value
+    end
+
+    def blank?(value)
+      return true if value.nil?
+      return true if value.is_a?(String) && value.strip.empty?
+      return value.empty? if value.respond_to?(:empty?)
+
+      false
+    end
+
+    def present?(value)
+      !blank?(value)
+    end
+
+    def presence(value)
+      present?(value) ? value : nil
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: stacked-pdf-generator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeremy
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stacking-order
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Wraps pdfjam/podofocrop/pdfinfo to automate stacked layouts, relying
+  on stacking-order for sequencing.
+email:
+- jeremy@example.com
+executables:
+- stacked-pdf-generator
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/stacked-pdf-generator
+- lib/stacked_pdf_generator.rb
+- lib/stacked_pdf_generator/version.rb
+homepage: https://github.com/jeremy/stacked-pdf-generator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jeremy/stacked-pdf-generator
+  source_code_uri: https://github.com/jeremy/stacked-pdf-generator
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Generate stack-cut friendly PDFs using pdfjam.
+test_files: []