acro_that 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa3b37611a5ca19d2cb0fa1c86d3821fb139b6f65ce9d3cd314d913b6e9e5db5
-  data.tar.gz: a4d07aaa7f268eb151b324b03e9575f563880b2cf97fd0172edc0e96c35e6eef
+  metadata.gz: 56f6be44d023bdedaf254cc097d18791f284793d0c79c07847fd462c0643cc91
+  data.tar.gz: b649d290433fac6a6113a74ca47bfde60e31687f6e93b85e30c32053ee416b3a
 SHA512:
-  metadata.gz: a545eea311d77e7b46459e710925f8ec7b61baebd846ec7f602f6a77ab9532bab87d37be4bba53b00b43a09281e79faba79fcb71e5371c36953e877d556dcdd8
-  data.tar.gz: b9074d19a0cc330af44f4fd5609f49f8892e20deb95d522fa7ca5fb3099ca8c71f01cbc98ef7d3e6ed95620af090afc96035fbeaaf4a551ca6f9e4003c49f4a8
+  metadata.gz: b27c5ec88a2cfdec49750d9d3316979c90c0815461eb6281b4cf602dc6533c8761c8fba7fb49407256b9ade87f2f3731e8f9d121c4ef089d08be2901107cc295
+  data.tar.gz: f1b41cef40049564af8f081547460d72e787a721f676db4c80cd74eb21844b48364ac3b871e6ad2839505908d9e5be3b8d643c16812bd91ae6d0e858bcfb51eb

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/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|
@@ -554,8 +526,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 +677,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 +687,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/version.rb

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

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.3
 platform: ruby
 authors:
 - Michael Wynkoop
@@ -118,6 +118,7 @@ files:
 - lib/acro_that/objstm.rb
 - lib/acro_that/pdf_writer.rb
 - lib/acro_that/version.rb
+- publish
 homepage: https://github.com/wynk182/acro_that
 licenses:
 - MIT