acro_that 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa3b37611a5ca19d2cb0fa1c86d3821fb139b6f65ce9d3cd314d913b6e9e5db5
-  data.tar.gz: a4d07aaa7f268eb151b324b03e9575f563880b2cf97fd0172edc0e96c35e6eef
+  metadata.gz: 40016774a590828e59c4c9ea4331a8d170ccd536d7522cbdb193fefda3f28333
+  data.tar.gz: bade6f113359d96d1f7c1a85efd7033732350c0b19bf40dd412e104da359aa5a
 SHA512:
-  metadata.gz: a545eea311d77e7b46459e710925f8ec7b61baebd846ec7f602f6a77ab9532bab87d37be4bba53b00b43a09281e79faba79fcb71e5371c36953e877d556dcdd8
-  data.tar.gz: b9074d19a0cc330af44f4fd5609f49f8892e20deb95d522fa7ca5fb3099ca8c71f01cbc98ef7d3e6ed95620af090afc96035fbeaaf4a551ca6f9e4003c49f4a8
+  metadata.gz: 60e6c6afd93cfd8911c0b0a0d4b6b080cb2c8af85a104cf3fd09f8fc7f9ac642999a8d5694c374ad64b71d4aa769f6d8b390cc82829317abd64598aa42e7280f
+  data.tar.gz: 31762cf9f6f285edd78976692e9c5bab7a67cf6298a03c8d4208b02927639be29e0d1f4ca1f14c3f1c170b9f617404e0931dc8bbedd17de79fcee5c80035dd29

data/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.3] - 2025-01-XX
+
+### Fixed
+- Fixed bug where fields added to multi-page PDFs were all placed on the same page. Fields now correctly appear on their specified pages when using the `page` option in `add_field`.
+
+### Changed
+- Refactored page-finding logic to eliminate code duplication across `Document` and `AddField` classes
+- Unified page discovery through `Document#find_all_pages` and `Document#find_page_by_number` methods
+- Updated all page detection patterns to use centralized `DictScan.is_page?` utility method
+
+### Added
+- `DictScan.is_page?` utility method for consistent page object detection across the codebase
+- `Document#find_all_pages` private method for unified page discovery in document order
+- `Document#find_page_by_number` private method for finding pages by page number
+- Exposed `find_page_by_number` through `Base` module for use in action classes
+
 ## [0.1.1] - 2025-10-31
 
 ### Added

data/README.md

@@ -234,6 +234,32 @@ fields.each do |field|
 end
 ```
 
+#### `#list_pages`
+Returns an array of `Page` objects representing all pages in the document. Each `Page` object provides page information and methods to add fields to that specific page.
+
+```ruby
+pages = doc.list_pages
+pages.each do |page|
+  puts "Page #{page.page_number}: #{page.width}x#{page.height}"
+end
+
+# Add fields to specific pages - the page is automatically set!
+first_page = pages[0]
+first_page.add_field("Name", x: 100, y: 700, width: 200, height: 20)
+
+second_page = pages[1]
+second_page.add_field("Email", x: 100, y: 650, width: 200, height: 20)
+```
+
+**Page Object Methods:**
+- `page.page_number` - Returns the page number (1-indexed)
+- `page.width` - Page width in points
+- `page.height` - Page height in points
+- `page.ref` - Page object reference `[obj_num, gen_num]`
+- `page.metadata` - Hash containing page metadata (rotation, boxes, etc.)
+- `page.add_field(name, options)` - Add a field to this page (page number is automatically set)
+- `page.to_h` - Convert to hash for backward compatibility
+
 #### `#add_field(name, options)`
 Adds a new form field to the document. Options include:
 - `value`: Default value for the field (String)

data/lib/acro_that/actions/add_field.rb

@@ -153,61 +153,8 @@ module AcroThat
       end
 
       def find_page_ref(page_num)
-        page_objects = []
-        resolver.each_object do |ref, body|
-          next unless body
-
-          # Check for /Type /Page (actual page, not /Type/Pages)
-          # Must match /Type /Page or /Type/Page but NOT /Type/Pages
-          is_page = body.include?("/Type /Page") ||
-                    (body =~ %r{/Type\s*/Page(?!s)\b})
-          next unless is_page
-
-          page_objects << ref
-        end
-
-        # If still no pages found, try to find them via the page tree
-        if page_objects.empty?
-          # Find the document catalog's /Pages entry
-          root_ref = resolver.root_ref
-          if root_ref
-            catalog_body = resolver.object_body(root_ref)
-            if catalog_body && catalog_body =~ %r{/Pages\s+(\d+)\s+(\d+)\s+R}
-              pages_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
-              pages_body = resolver.object_body(pages_ref)
-
-              # Extract /Kids array from Pages object
-              if pages_body && pages_body =~ %r{/Kids\s*\[(.*?)\]}m
-                kids_array = ::Regexp.last_match(1)
-                # Extract all object references from Kids array
-                kids_array.scan(/(\d+)\s+(\d+)\s+R/) do |num_str, gen_str|
-                  kid_ref = [num_str.to_i, gen_str.to_i]
-                  kid_body = resolver.object_body(kid_ref)
-                  # Check if this kid is a page (not /Type/Pages)
-                  if kid_body && (kid_body.include?("/Type /Page") || kid_body =~ %r{/Type\s*/Page(?!s)\b})
-                    page_objects << kid_ref
-                  elsif kid_body && kid_body.include?("/Type /Pages")
-                    # Recursively find pages in this Pages node
-                    if kid_body =~ %r{/Kids\s*\[(.*?)\]}m
-                      kid_body[::Regexp.last_match(0)..].scan(/(\d+)\s+(\d+)\s+R/) do |n, g|
-                        grandkid_ref = [n.to_i, g.to_i]
-                        grandkid_body = resolver.object_body(grandkid_ref)
-                        if grandkid_body && (grandkid_body.include?("/Type /Page") || grandkid_body =~ %r{/Type\s*/Page(?!s)\b})
-                          page_objects << grandkid_ref
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        return page_objects[0] if page_objects.empty?
-        return page_objects[page_num - 1] if page_num.positive? && page_num <= page_objects.length
-
-        page_objects[0]
+        # Use Document's unified page-finding method
+        find_page_by_number(page_num)
       end
 
       def add_widget_to_page(widget_obj_num, page_num)

data/lib/acro_that/actions/base.rb

@@ -39,6 +39,10 @@ module AcroThat
       def acroform_ref
         @document.send(:acroform_ref)
       end
+
+      def find_page_by_number(page_num)
+        @document.send(:find_page_by_number, page_num)
+      end
     end
   end
 end

data/lib/acro_that/actions/remove_field.rb

@@ -107,11 +107,7 @@ module AcroThat
         page_objects = []
         resolver.each_object do |ref, body|
           next unless body
-
-          is_page = body.include?("/Type /Page") ||
-                    body.include?("/Type/Page") ||
-                    (body.include?("/Type") && body.include?("/Page") && body =~ %r{/Type\s*/Page})
-          next unless is_page
+          next unless DictScan.is_page?(body)
 
           page_objects << ref
         end

data/lib/acro_that/dict_scan.rb

@@ -316,6 +316,13 @@ module AcroThat
       body.include?("/Subtype") && body.include?("/Widget") && body =~ %r{/Subtype\s*/Widget}
     end
 
+    # Check if a body represents a page object (not /Type/Pages)
+    def is_page?(body)
+      return false unless body
+
+      body.include?("/Type /Page") || body =~ %r{/Type\s*/Page(?!s)\b}
+    end
+
     # Check if a field is multiline by checking /Ff flag bit 12 (0x1000)
     def is_multiline_field?(dict_body)
       return false unless dict_body

data/lib/acro_that/document.rb

@@ -74,35 +74,7 @@ module AcroThat
     # Return an array of page information (page number, width, height, ref, metadata)
     def list_pages
       pages = []
-      page_objects = []
-
-      # Try to get pages in document order via page tree first
-      root_ref = @resolver.root_ref
-      if root_ref
-        catalog_body = @resolver.object_body(root_ref)
-        if catalog_body && catalog_body =~ %r{/Pages\s+(\d+)\s+(\d+)\s+R}
-          pages_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
-
-          # Recursively collect pages from page tree
-          collect_pages_from_tree(pages_ref, page_objects)
-        end
-      end
-
-      # Fallback: collect all page objects if page tree didn't work
-      if page_objects.empty?
-        @resolver.each_object do |ref, body|
-          next unless body
-
-          # Match /Type /Page or /Type/Page but NOT /Type/Pages
-          is_page = body.include?("/Type /Page") || body =~ %r{/Type\s*/Page(?!s)\b}
-          next unless is_page
-
-          page_objects << ref unless page_objects.include?(ref)
-        end
-
-        # Sort by object number as fallback
-        page_objects.sort_by! { |ref| ref[0] }
-      end
+      page_objects = find_all_pages
 
       # Second pass: extract information from each page
       page_objects.each_with_index do |ref, index|
@@ -207,13 +179,14 @@ module AcroThat
           contents_refs: contents_refs
         }
 
-        pages << {
-          page: index + 1, # Page number starting at 1
-          width: width,
-          height: height,
-          ref: ref,
-          metadata: metadata
-        }
+        pages << Page.new(
+          index + 1, # Page number starting at 1
+          width,
+          height,
+          ref,
+          metadata,
+          self # Pass document reference
+        )
       end
 
       pages
@@ -554,8 +527,7 @@ module AcroThat
         end
 
         body = obj[:body]
-        # Match /Type /Page or /Type/Page but NOT /Type/Pages
-        next unless body&.include?("/Type /Page") || body =~ %r{/Type\s*/Page(?!s)\b}
+        next unless DictScan.is_page?(body)
 
         # Handle inline /Annots array
         if body =~ %r{/Annots\s*\[(.*?)\]}
@@ -706,7 +678,7 @@ module AcroThat
           kid_body = @resolver.object_body(kid_ref)
 
           # Check if this kid is a page (not /Type/Pages)
-          if kid_body && (kid_body.include?("/Type /Page") || kid_body =~ %r{/Type\s*/Page(?!s)\b})
+          if kid_body && DictScan.is_page?(kid_body)
             page_objects << kid_ref unless page_objects.include?(kid_ref)
           elsif kid_body && kid_body.include?("/Type /Pages")
             # Recursively find pages in this Pages node
@@ -716,14 +688,52 @@ module AcroThat
       end
     end
 
-    def find_page_number_for_ref(page_ref)
+    # Find all page objects in document order
+    # Returns an array of page references [obj_num, gen_num]
+    def find_all_pages
       page_objects = []
-      @resolver.each_object do |ref, body|
-        next unless body&.include?("/Type /Page")
 
-        page_objects << ref
+      # First, try to get pages in document order via page tree
+      root_ref = @resolver.root_ref
+      if root_ref
+        catalog_body = @resolver.object_body(root_ref)
+        if catalog_body && catalog_body =~ %r{/Pages\s+(\d+)\s+(\d+)\s+R}
+          pages_ref = [Integer(::Regexp.last_match(1)), Integer(::Regexp.last_match(2))]
+          collect_pages_from_tree(pages_ref, page_objects)
+        end
+      end
+
+      # Fallback: collect all page objects if page tree didn't work
+      if page_objects.empty?
+        @resolver.each_object do |ref, body|
+          next unless body
+
+          next unless DictScan.is_page?(body)
+
+          page_objects << ref unless page_objects.include?(ref)
+        end
+
+        # Sort by object number as fallback
+        page_objects.sort_by! { |ref| ref[0] }
       end
 
+      page_objects
+    end
+
+    # Find a page by its page number (1-indexed)
+    # Returns [obj_num, gen_num] or nil if not found
+    def find_page_by_number(page_num)
+      page_objects = find_all_pages
+
+      return nil if page_objects.empty?
+      return page_objects[page_num - 1] if page_num.positive? && page_num <= page_objects.length
+
+      page_objects[0] # Default to first page if page_num is out of range
+    end
+
+    def find_page_number_for_ref(page_ref)
+      page_objects = find_all_pages
+
       return nil if page_objects.empty?
 
       page_index = page_objects.index(page_ref)

data/lib/acro_that/page.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AcroThat
+  # Represents a page in a PDF document
+  class Page
+    attr_reader :page, :width, :height, :ref, :metadata, :document
+
+    def initialize(page, width, height, ref, metadata, document)
+      @page = page # Page number (1-indexed)
+      @width = width
+      @height = height
+      @ref = ref # [obj_num, gen_num]
+      @metadata = metadata # Hash with :rotate, :media_box, :crop_box, etc.
+      @document = document
+    end
+
+    # Add a field to this page
+    # Options are the same as Document#add_field, but :page is automatically set
+    def add_field(name, options = {})
+      # Automatically set the page number to this page
+      options_with_page = options.merge(page: @page)
+      @document.add_field(name, options_with_page)
+    end
+
+    # Get the page number
+    def page_number
+      @page
+    end
+
+    # Get the page reference [obj_num, gen_num]
+    def page_ref
+      @ref
+    end
+
+    # Check if page has rotation
+    def rotated?
+      !@metadata[:rotate].nil? && @metadata[:rotate] != 0
+    end
+
+    # Get rotation angle (0, 90, 180, 270)
+    def rotation
+      @metadata[:rotate] || 0
+    end
+
+    # Get MediaBox dimensions
+    def media_box
+      @metadata[:media_box]
+    end
+
+    # Get CropBox dimensions
+    def crop_box
+      @metadata[:crop_box]
+    end
+
+    # Get ArtBox dimensions
+    def art_box
+      @metadata[:art_box]
+    end
+
+    # Get BleedBox dimensions
+    def bleed_box
+      @metadata[:bleed_box]
+    end
+
+    # Get TrimBox dimensions
+    def trim_box
+      @metadata[:trim_box]
+    end
+
+    # String representation for debugging
+    def to_s
+      dims = width && height ? " #{width}x#{height}" : ""
+      rot = rotated? ? " (rotated #{rotation}°)" : ""
+      "#<AcroThat::Page page=#{page}#{dims}#{rot} ref=#{ref.inspect}>"
+    end
+
+    alias inspect to_s
+
+    # Convert to hash for backward compatibility
+    def to_h
+      {
+        page: @page,
+        width: @width,
+        height: @height,
+        ref: @ref,
+        metadata: @metadata
+      }
+    end
+  end
+end
+

data/lib/acro_that/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcroThat
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/acro_that.rb

@@ -12,6 +12,7 @@ require_relative "acro_that/objstm"
 require_relative "acro_that/pdf_writer"
 require_relative "acro_that/incremental_writer"
 require_relative "acro_that/field"
+require_relative "acro_that/page"
 require_relative "acro_that/document"
 
 # Load actions

data/publish

@@ -0,0 +1,183 @@
+#!/bin/bash
+
+set -e  # Exit on any error
+
+VERSION_FILE="lib/acro_that/version.rb"
+GEMSPEC_FILE="acro_that.gemspec"
+GEM_NAME="acro_that"
+
+# Function to show usage
+usage() {
+    cat << EOF
+Usage: $0 [OPTIONS]
+
+Publish acro_that gem to RubyGems.
+
+OPTIONS:
+    -b, --bump TYPE        Bump version before publishing (major|minor|patch)
+    -k, --key KEY         RubyGems API key name (optional, uses credentials if not provided)
+    -h, --help            Show this help message
+
+EXAMPLES:
+    $0                     # Publish current version without bumping
+    $0 -b patch            # Bump patch version (0.1.2 -> 0.1.3)
+    $0 -b minor            # Bump minor version (0.1.2 -> 0.2.0)
+    $0 -b major            # Bump major version (0.1.2 -> 1.0.0)
+    $0 -b patch -k mykey   # Bump patch and use specific API key
+
+EOF
+    exit 1
+}
+
+# Function to get current version
+get_current_version() {
+    if [[ ! -f "$VERSION_FILE" ]]; then
+        echo "Error: $VERSION_FILE not found!" >&2
+        exit 1
+    fi
+    
+    # Extract version using awk (works reliably on both macOS and Linux)
+    awk -F'"' '/VERSION =/ {print $2}' "$VERSION_FILE"
+}
+
+# Function to bump version
+bump_version() {
+    local bump_type=$1
+    local current_version=$(get_current_version)
+    
+    IFS='.' read -ra VERSION_PARTS <<< "$current_version"
+    local major=${VERSION_PARTS[0]:-0}
+    local minor=${VERSION_PARTS[1]:-0}
+    local patch=${VERSION_PARTS[2]:-0}
+    
+    case "$bump_type" in
+        major)
+            major=$((major + 1))
+            minor=0
+            patch=0
+            ;;
+        minor)
+            minor=$((minor + 1))
+            patch=0
+            ;;
+        patch)
+            patch=$((patch + 1))
+            ;;
+        *)
+            echo "Error: Invalid bump type: $bump_type" >&2
+            echo "Must be one of: major, minor, patch" >&2
+            exit 1
+            ;;
+    esac
+    
+    local new_version="${major}.${minor}.${patch}"
+    
+    # Update version in version.rb
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS uses BSD sed
+        sed -i '' "s/VERSION = \".*\"/VERSION = \"$new_version\"/" "$VERSION_FILE"
+    else
+        # Linux uses GNU sed
+        sed -i "s/VERSION = \".*\"/VERSION = \"$new_version\"/" "$VERSION_FILE"
+    fi
+    
+    echo "$new_version"
+}
+
+# Parse arguments
+BUMP_TYPE=""
+API_KEY=""
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -b|--bump)
+            BUMP_TYPE="$2"
+            shift 2
+            ;;
+        -k|--key)
+            API_KEY="$2"
+            shift 2
+            ;;
+        -h|--help)
+            usage
+            ;;
+        *)
+            echo "Error: Unknown option: $1" >&2
+            usage
+            ;;
+    esac
+done
+
+# Validate bump type if provided
+if [[ -n "$BUMP_TYPE" ]]; then
+    if [[ ! "$BUMP_TYPE" =~ ^(major|minor|patch)$ ]]; then
+        echo "Error: Invalid bump type: $BUMP_TYPE" >&2
+        echo "Must be one of: major, minor, patch" >&2
+        exit 1
+    fi
+fi
+
+# Get version (after potential bump)
+if [[ -n "$BUMP_TYPE" ]]; then
+    echo "Bumping $BUMP_TYPE version..."
+    VERSION=$(bump_version "$BUMP_TYPE")
+    echo "New version: $VERSION"
+else
+    VERSION=$(get_current_version)
+    echo "Using current version: $VERSION"
+fi
+
+# Build the gem
+echo "Building gem..."
+GEM_FILE="${GEM_NAME}-${VERSION}.gem"
+gem build "$GEMSPEC_FILE"
+
+if [[ ! -f "$GEM_FILE" ]]; then
+    echo "Error: Failed to build gem file: $GEM_FILE" >&2
+    exit 1
+fi
+
+echo "Gem built successfully: $GEM_FILE"
+
+# Push to RubyGems
+echo "Pushing to RubyGems..."
+if [[ -n "$API_KEY" ]]; then
+    gem push "$GEM_FILE" --key "$API_KEY"
+else
+    gem push "$GEM_FILE"
+fi
+
+if [[ $? -ne 0 ]]; then
+    echo "Error: Failed to push gem to RubyGems" >&2
+    exit 1
+fi
+
+echo "Gem pushed to RubyGems successfully"
+
+# Commit and push to git (only if version was bumped or if there are changes)
+if [[ -n "$BUMP_TYPE" ]] || ! git diff --quiet "$VERSION_FILE"; then
+    echo "Committing version change..."
+    git add "$VERSION_FILE"
+    git commit -m "v${VERSION}"
+    
+    echo "Creating and pushing tag..."
+    git tag -a "v${VERSION}" -m "Release version ${VERSION}"
+    
+    echo "Pushing to origin..."
+    git push origin main
+    git push origin "v${VERSION}"
+    
+    echo "Git operations completed successfully"
+else
+    echo "No version changes to commit"
+fi
+
+echo ""
+echo "✅ Successfully published ${GEM_NAME} v${VERSION}!"
+echo "   - Gem built: ${GEM_FILE}"
+echo "   - Pushed to RubyGems"
+if [[ -n "$BUMP_TYPE" ]]; then
+    echo "   - Version bumped and committed"
+    echo "   - Tagged as v${VERSION}"
+fi
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acro_that
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Michael Wynkoop
@@ -116,8 +116,10 @@ files:
 - lib/acro_that/incremental_writer.rb
 - lib/acro_that/object_resolver.rb
 - lib/acro_that/objstm.rb
+- lib/acro_that/page.rb
 - lib/acro_that/pdf_writer.rb
 - lib/acro_that/version.rb
+- publish
 homepage: https://github.com/wynk182/acro_that
 licenses:
 - MIT