Walkthrough

Adds a rake-based license verification task, a LicenseTaskFormatter module to produce text/JSON outputs and compute expiration/renewal flags, RSpec tests for the formatter, and documentation including a GitHub Actions workflow to check license expiry and optionally open/label renewal issues.

Changes

Sequence Diagram(s)

sequenceDiagram
  participant Scheduler as Scheduler (GitHub Actions)
  participant Runner as Runner (Actions)
  participant App as Rails App (rake task)
  participant Parser as JSON Parser (jq)
  participant GH as GitHub API

  Scheduler->>Runner: trigger scheduled workflow
  Runner->>App: run `bundle exec rake react_on_rails_pro:verify_license FORMAT=json`
  App-->>Runner: emit JSON license status
  Runner->>Parser: parse JSON for status & days_remaining
  Parser-->>Runner: parsed status + days
  alt renewal required or expired
    Runner->>GH: search existing issues (dedupe)
    alt no duplicate found
      Runner->>GH: create issue
      Runner->>GH: add label(s)
    end
  end

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Poem

🐇 I hopped through JSON, counted days with care,

I nudged the rake and whispered, "Do your share."
If expiry nears or certificates sigh,
I'll tap the issue door and give a soft cry.
Small checks, tidy notes — a rabbit's little repair.

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Greptile Overview

Greptile Summary

Adds react_on_rails_pro:verify_license rake task with dual output formats (human-readable text and machine-parseable JSON). The implementation cleanly separates formatting logic into LicenseTaskFormatter module, which calculates days_remaining and renewal_required fields from existing LicenseValidator.license_info. The task exits with code 1 for non-valid licenses (expired, invalid, missing) and code 0 for valid licenses.

Key changes:

• New LicenseTaskFormatter module handles all output formatting
• Rake task uses raise (composable with rake dependencies) instead of exit 1 per previous feedback
• JSON format controlled via FORMAT=json env var
• renewal_required flag triggers at ≤30 days or expired status
• Comprehensive test suite with 10 specs covering all status scenarios
• Documentation updated with complete GitHub Actions example for automated license monitoring

Documentation note: The GitHub Actions workflow includes a note about jq pre-installation on ubuntu-latest runners, addressing previous review feedback.

Confidence Score: 5/5

• Safe to merge with no blocking issues
• Implementation is clean, well-tested, and addresses all previous review feedback. The formatter module has excellent separation of concerns, comprehensive test coverage, and the rake task correctly uses raise for composability. Documentation is thorough with helpful examples and appropriate caveats about jq availability.
• No files require special attention

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant User
    participant RakeTask as verify_license rake task
    participant Formatter as LicenseTaskFormatter
    participant Validator as LicenseValidator
    participant ENV as Environment/Config

    User->>RakeTask: bundle exec rake react_on_rails_pro:verify_license
    Note over User,RakeTask: Optional: FORMAT=json env var
    
    RakeTask->>ENV: ENV.fetch("FORMAT", "text")
    ENV-->>RakeTask: format (text or json)
    
    RakeTask->>Validator: license_info()
    Validator->>ENV: load_license_string()
    ENV-->>Validator: JWT token
    Validator->>Validator: decode & validate JWT
    Validator-->>RakeTask: info hash {status, org, plan, expiration, attribution_required}
    
    RakeTask->>Formatter: build_result(info)
    Formatter->>Formatter: calculate days_remaining
    Formatter->>Formatter: set renewal_required
    Formatter-->>RakeTask: result hash
    
    alt JSON format
        RakeTask->>RakeTask: JSON.pretty_generate(result)
        RakeTask->>User: JSON output
    else Text format
        RakeTask->>Formatter: print_text(result, info)
        Formatter->>User: Formatted text output
    end
    
    alt status != :valid
        RakeTask->>RakeTask: raise error
        RakeTask-->>User: exit code 1
    else status == :valid
        RakeTask-->>User: exit code 0
    end

Code Review

I found one issue that should be addressed:

Missing CHANGELOG Entry

This PR adds a new user-visible feature (rake react_on_rails_pro:verify_license task with JSON output for CI) that should be documented in the CHANGELOG.

According to AGENTS.md line 165-168:

Update /CHANGELOG.md for user-visible changes only (features, bug fixes, breaking changes, deprecations, performance improvements).

Since this is a Pro-only feature, it should be added to CHANGELOG.md under the #### Pro section under ##### Added.

Suggested entry:

- **License verification rake task**: New `react_on_rails_pro:verify_license` rake task for checking license validity with both human-readable text output and JSON format (`FORMAT=json`) for CI/CD integration. Includes exit codes (0 for valid, 1 for invalid/expired), automatic renewal warnings for licenses expiring within 30 days, and comprehensive JSON output with all license details. [PR 2385](https://github.com/shakacode/react_on_rails/pull/2385) by [justin808](https://github.com/justin808).

Otherwise, the implementation looks solid with comprehensive test coverage and excellent documentation.

@greptile, review this PR.
@claude, review this PR.

Claude finished @justin808's task in 1m 43s —— View job

PR Review Complete

Todo List

• Read repository guidelines (CLAUDE.md, AGENTS.md)
• Review all changed files
• Check if previous review comments were addressed
• Analyze code quality and correctness
• Check CHANGELOG entry
• Post comprehensive review feedback

Summary

This PR adds a well-designed rake react_on_rails_pro:verify_license task with both human-readable text output and machine-readable JSON for CI/CD integration. The implementation is solid, test coverage is comprehensive, and documentation is excellent. Previous review issues have been addressed in commits b4c9261, 1e4900e, 8c4eeef, and 59e9ed2.

Issues Found

❌ Missing CHANGELOG Entry

According to AGENTS.md:165-168, user-visible changes require a CHANGELOG entry. This PR adds a new user-facing feature that should be documented.

Required Action: Add an entry to CHANGELOG.md under #### Pro → ##### Added:

- **License verification rake task**: New `react_on_rails_pro:verify_license` rake task for checking license validity with both human-readable text output and JSON format (`FORMAT=json`) for CI/CD integration. Includes exit codes (0 for valid, 1 for invalid/expired), automatic renewal warnings for licenses expiring within 30 days, and comprehensive JSON output with all license details. See LICENSE_SETUP.md for usage examples including GitHub Actions workflow. [PR 2385](https://github.com/shakacode/react_on_rails/pull/2385) by [justin808](https://github.com/justin808).

What Works Well

✅ Code Quality

react_on_rails_pro/lib/react_on_rails_pro/license_task_formatter.rb:1-74

• Clean separation of concerns: formatter is pure Ruby, no rake dependencies
• Well-structured methods with single responsibilities
• Proper use of module_function for utility module
• Good naming conventions throughout

react_on_rails_pro/lib/tasks/license.rake:1-21

• Simple, focused rake task
• Uses raise (line 19) which is appropriate for rake tasks (per commit 59e9ed2)
• Clean integration with the formatter module
• Case-insensitive FORMAT detection (line 12)

✅ Test Coverage

react_on_rails_pro/spec/react_on_rails_pro/license_task_formatter_spec.rb:1-235

• Comprehensive coverage: valid, expired, missing, and expiring-soon scenarios
• Tests both text and JSON output formats
• Proper use of JWT fixtures with test key pairs
• Good use of RSpec patterns: let blocks, context blocks, named subjects
• Clean helper method capture_stdout (lines 227-234)

✅ Documentation

react_on_rails_pro/LICENSE_SETUP.md:114-249

• Excellent user-facing documentation
• Clear examples for both text and JSON output
• Complete GitHub Actions workflow example with deduplication logic
• Explicit note about jq being pre-installed on ubuntu-latest (lines 173-175) - addresses Greptile's concern
• JSON field table is comprehensive and helpful (lines 158-167)

✅ Previous Review Issues Addressed

All issues from CodeRabbit and Greptile reviews have been resolved:

• ✅ Markdown language specifier added (commit 1e4900e)
• ✅ Multiline JSON output removed from GitHub Actions example (commit b4c9261)
• ✅ Formatter extracted to separate file (commit 8c4eeef)
• ✅ Changed from exit 1 to raise for composability (commit 59e9ed2)
• ✅ Added jq availability note (commit 8c4eeef)
• ✅ Formatter is in its own file, no global rake task pollution in specs

Code Review Notes

Design Decisions (All Good)

1. Exit code strategy: Using raise (line 19) is the right choice for rake tasks - it provides composability while still exiting with code 1 when run standalone.

2. JSON schema design: The renewal_required flag (lines 16, 26) is excellent for automation - flips to true when ≤ 30 days remain OR expired.

3. Date formatting: ISO 8601 for JSON (line 13), human-readable for text (line 59) - appropriate for each context.

4. Days calculation: Uses ceil (line 24) which is correct - "15.1 days" should show as "16 days left" to be conservative.

Minor Observations (Non-blocking)

1. Line 8-9 in license.rake: Format detection with ENV.fetch("FORMAT", "text") works well, though ENV.fetch("FORMAT", "text").downcase would make line 12 simpler. Not worth changing.

2. Lines 30-72 in formatter: The text printing methods are well-organized but could theoretically be split into a separate presenter class if they grow. Current structure is fine for this scope.

3. Security note: GitHub Actions workflow (lines 215-220) interpolates outputs into JavaScript. While the risk is minimal (values come from your own rake task), CodeRabbit's suggestion to use environment variables is a valid hardening approach if you want defense-in-depth.

Test Results Mentioned in PR

According to the PR description:

• ✅ All 10 new specs pass for LicenseTaskFormatter
• ✅ All 59 existing LicenseValidator specs still pass
• ✅ RuboCop passes with no offenses
• ⏳ CI pending

Overall Assessment

Ready to merge once CHANGELOG entry is added. The implementation is production-ready with excellent test coverage and documentation. All previous review concerns have been addressed.

Code review

No issues found. Checked for bugs and CLAUDE.md compliance.