stacking-order 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13c66a0c61b2744526f1e6113775629730d07cda8d528630c103f5ae276bce4f
-  data.tar.gz: b8133c884d749092af5cb11e4b8b6879127cefb6a1f557fb95ba2eac888d738c
+  metadata.gz: 480df27d8a79f4868585d1e3d7bba83e25c1567405b36ab60d38d4bab161c602
+  data.tar.gz: 0d729b3fdeb4a8306a2f35930aa549ba3f800e594871be54241caafada54a240
 SHA512:
-  metadata.gz: 0eb9c0442393fea05b44c548f4ce5f249cdc64e0e13843cfc8200ba15e0f08797eda11f3ed9856b00cc521d36ef0d815d7f66cd6bcb7fd562f0c58c373afc4d5
-  data.tar.gz: 0d2a23b921e1341f76e0373844150e3fa633d83f186cbb3e6b2ee8817150d98898933ec7cd492ea621831e83f7007203d7bbe2b1caf6198a4742b54809534628
+  metadata.gz: a02a2a4642f48f6d81a9e3aa3d91497b62ae2ceb4a86d1e71efa27e282945e0af775da8ac0098ab978cf2a64dbd8e60497d37dfdf78e6ccfeeaf602010010a5b
+  data.tar.gz: ba7e487c563a741ce4d518bb4974459fae90ed0aaa8b696ca2451cfd512d8283c3d128e5e52960bd31329aa8f1a16f3f394faa67321907748c1d614106a5f391

data/README.md

@@ -2,8 +2,14 @@
 
 A tiny Ruby gem that computes how to arrange records on a paginated grid so that,
 after cutting the printed stack into columns and re-stacking them, the final pile
-remains in sequential order. It is useful for printing badges, tickets, or any
-other grid-based layout that is cut in bulk.
+remains in sequential order.
+
+It is useful for printing badges, tickets, or any other grid-based layout that is
+cut in bulk.
+
+It has a `two_sided_flipped` option to support printing on both sides of the
+paper, with the second side flipped, which can be used for printing traditional
+Tibetan books (called pechas) or for similar texts from various traditions.
 
 ## Installation
 
@@ -28,6 +34,9 @@ order = StackingOrder.order(entries: 13, rows: 2, columns: 2)
 # => [1, 5, 9, 13, 2, 6, 10, nil, 3, 7, 11, nil, 4, 8, 12]
 # nil entries mark empty slots on the final, partially filled page.
 
+StackingOrder.order(entries: 8, rows: 2, columns: 2, two_sided_flipped: true)
+# => [1, 5, 6, 2, 3, 7, 8, 4]
+
 StackingOrder.visualize(entries: 6, rows: 2, columns: 2)
 # Prints page-by-page grids plus the stack order after cutting.
 ```
@@ -78,11 +87,12 @@ page-by-page grids and stack order) and returns non-zero on invalid arguments.
 
 ### Real-world usage
 
-This gem powers the stacking order calculations in
-[pecha-printer](https://github.com/jerefrer/pecha-printer), which itself backs
-the hosted service at <https://pecha-printer.frerejeremy.me>. By publishing the
-logic as a gem, the same algorithm can be reused by other Ruby/Rails projects or
-invoked manually via the CLI.
+This gem powers [stacked-pdf-generator](https://github.com/jeremy/stacked-pdf-generator), which provides the pdfjam/podofocrop
+tooling for producing final print-ready stacks.
+
+In turn, stacked-pdf-generator is used by [pecha-printer](https://github.com/jerefrer/pecha-printer) and the hosted service at
+<https://pecha-printer.frerejeremy.me>. Publishing the stacking logic separately lets other
+Ruby/Rails projects (or CLI scripts) reuse it without needing the full PDF pipeline.
 
 ## Development
 

data/lib/stacking_order/version.rb

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

data/lib/stacking_order.rb

@@ -14,7 +14,7 @@ module StackingOrder
   # @param rows [Integer] Number of rows in the grid on each page
   # @param columns [Integer] Number of columns in the grid on each page
   # @return [Array<Integer, nil>] The order in which to print entries (with nil for empty cells)
-  def order(entries:, rows:, columns:)
+  def order(entries:, rows:, columns:, two_sided_flipped: false)
     validate_arguments!(entries, rows, columns)
 
     return [] if entries.zero?
@@ -31,6 +31,10 @@ module StackingOrder
       end
     end
 
+    if two_sided_flipped
+      result = apply_two_sided_flip(result, rows, columns)
+    end
+
     result.pop while result.last.nil?
     result
   end
@@ -38,8 +42,8 @@ module StackingOrder
   # Utility method that prints the layout for the provided configuration,
   # showing the entries on each page and the resulting stacks after cutting.
   # Useful for debugging or CLI demos.
-  def visualize(entries:, rows:, columns:, io: $stdout)
-    result = order(entries: entries, rows: rows, columns: columns)
+  def visualize(entries:, rows:, columns:, two_sided_flipped: false, io: $stdout)
+    result = order(entries: entries, rows: rows, columns: columns, two_sided_flipped: two_sided_flipped)
     cells_per_page = rows * columns
     num_pages = (entries.to_f / cells_per_page).ceil
 
@@ -73,6 +77,35 @@ module StackingOrder
     end
   end
 
+  def apply_two_sided_flip(result, rows, columns)
+    cells_per_page = rows * columns
+    result.each_slice(cells_per_page).with_index.flat_map do |page, page_index|
+      padded_page = pad_page(page, cells_per_page)
+      page_index.odd? ? flip_page_rows(padded_page, rows, columns) : padded_page
+    end
+  end
+
+  def pad_page(page, cells_per_page)
+    return page if page.length == cells_per_page
+
+    page + Array.new(cells_per_page - page.length)
+  end
+
+  def flip_page_rows(page, rows, columns)
+    if rows == 1
+      row_slice = page.slice(0, columns) || []
+      return row_slice.reverse
+    end
+
+    flipped = []
+    rows.times do |row_index|
+      source_row_index = rows - 1 - row_index
+      row_slice = page.slice(source_row_index * columns, columns) || []
+      flipped.concat(row_slice)
+    end
+    flipped
+  end
+
   def validate_arguments!(entries, rows, columns)
     raise ArgumentError, 'entries must be non-negative' if entries.negative?
     raise ArgumentError, 'rows must be positive' if rows <= 0

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: stacking-order
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeremy
 bindir: exe
 cert_chain: []
-date: 2025-11-25 00:00:00.000000000 Z
+date: 2025-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest