diff --git a/.gitignore b/.gitignore index dc625cd89..1ac26b2a9 100644 --- a/.gitignore +++ b/.gitignore @@ -89,3 +89,4 @@ Image-ExifTool-* xxx/ *.jfr report.txt +exiftool_results.json diff --git a/dev/README.md b/dev/README.md index 56dc751bf..4ae9c31b6 100644 --- a/dev/README.md +++ b/dev/README.md @@ -13,6 +13,12 @@ This directory contains development resources, tools and experimental code for P - Architecture decisions and planning documents - Feature specifications and roadmaps +- **modules/** - CPAN module porting documentation + - Module compatibility guides (Moose, Moo, DateTime) + - XS fallback mechanisms and Java XS implementations + - jcpan client and MakeMaker documentation + - See [modules/README.md](modules/README.md) for module status + - **examples/** - Sample code and usage demonstrations Mix of working examples and feature concepts for design exploration. Not all examples are guaranteed to run. @@ -55,12 +61,13 @@ When adding new code or tools: 1. Place it in the appropriate category directory 2. Include clear documentation and usage examples 3. Add relevant tests where applicable -4. Reference related design documents from the `design/` directory +4. Reference related design documents from `design/` or `modules/` ## Development Guidelines - Keep experimental code separate from production code - Document design decisions in the `design/` directory +- Document module porting work in the `modules/` directory - Use the `bench/` directory for performance testing - Check `examples/` for implementation patterns - Store reusable LLM prompts in `prompts/` directory diff --git a/dev/design/README.md b/dev/design/README.md index 287d6a675..711114d60 100644 --- a/dev/design/README.md +++ b/dev/design/README.md @@ -51,6 +51,8 @@ The design documents cover: - **I/O & Signals:** File handles, signal handling, terminal control - **Distribution:** Packaging, versioning, platform support +> **Note:** Module porting documentation (CPAN modules, XS fallback, Moose/Moo support) has been moved to [`dev/modules/`](../modules/README.md). + --- ## Finding What You Need diff --git a/dev/design/JCPAN_DATETIME_FIXES.md b/dev/modules/JCPAN_DATETIME_FIXES.md similarity index 98% rename from dev/design/JCPAN_DATETIME_FIXES.md rename to dev/modules/JCPAN_DATETIME_FIXES.md index 6666ac61f..008a2737b 100644 --- a/dev/design/JCPAN_DATETIME_FIXES.md +++ b/dev/modules/JCPAN_DATETIME_FIXES.md @@ -307,5 +307,5 @@ mv.visitJumpInsn(Opcodes.GOTO, applyNoControlFlow); ## Related Documents -- `dev/design/cpan_client.md` - Main CPAN client documentation -- `dev/design/xsloader.md` - XSLoader implementation +- `cpan_client.md` - Main CPAN client documentation +- `xsloader.md` - XSLoader implementation diff --git a/dev/modules/README.md b/dev/modules/README.md new file mode 100644 index 000000000..942924bdb --- /dev/null +++ b/dev/modules/README.md @@ -0,0 +1,121 @@ +# Module Porting Documentation + +This directory contains design documents and guides related to porting CPAN modules to PerlOnJava. + +## Quick Reference + +| Document | Description | +|----------|-------------| +| [moose_support.md](moose_support.md) | Path to Moose/Class::MOP support (blocked by B module) | +| [moo_support.md](moo_support.md) | Moo support status (96% working) | +| [xs_fallback.md](xs_fallback.md) | XS fallback mechanism for pure Perl modules | +| [xsloader.md](xsloader.md) | XSLoader architecture | +| [makemaker_perlonjava.md](makemaker_perlonjava.md) | ExtUtils::MakeMaker implementation | +| [cpan_client.md](cpan_client.md) | jcpan - CPAN client for PerlOnJava | + +## Module Status Overview + +### Working Modules + +| Module | Status | Notes | +|--------|--------|-------| +| **Moo** | 96% tests pass | Recommended OO system | +| **DateTime** | Works | Java XS implementation | +| **JSON::PP** | Works | Built-in | +| **YAML** | Works | Pure Perl | +| **Try::Tiny** | Works | Pure Perl | +| **Test::More** | Works | Built-in | +| **DBI** | Works | Java implementation | + +### Modules Requiring Environment Variables + +| Module | Environment Variable | Notes | +|--------|---------------------|-------| +| Params::Util | `PERL_PARAMS_UTIL_PP=1` | Has PP fallback | +| Class::Load | Works after Params::Util | Has PP fallback | +| Package::Stash | Auto-fallback | Has PP fallback | + +### Not Yet Working + +| Module | Blocker | See | +|--------|---------|-----| +| Moose | B module subroutine names | [moose_support.md](moose_support.md) | +| Any XS-only module | No compiler | [xs_fallback.md](xs_fallback.md) | + +## Key Concepts + +### XS Fallback Pattern + +Many CPAN modules with XS code also provide pure Perl fallbacks: + +```perl +# Common pattern in modules +eval { + require XSLoader; + XSLoader::load(__PACKAGE__, $VERSION); +}; +if ($@) { + require Module::PP; # Pure Perl fallback +} +``` + +PerlOnJava's XSLoader returns an error matching `/loadable object/` which these modules recognize. + +### Java XS Implementations + +For performance-critical modules, PerlOnJava can provide Java implementations: + +- `DateTime` - Uses `java.time` APIs +- `JSON::XS` - Falls back to JSON::PP (or could use FASTJSON) +- `DBI` - Custom Java implementation with JDBC + +See [xs_fallback.md](xs_fallback.md) for implementation details. + +### Installing Modules + +Use `jcpan` for module installation: + +```bash +# Install a module +./jcpan install DateTime + +# Test a module +./jcpan -t Moo + +# With PP environment variables +PERL_PARAMS_UTIL_PP=1 ./jcpan -t Class::Load +``` + +## Adding Support for New Modules + +1. **Check if module has XS**: Look for `.xs` files in the distribution +2. **Check for PP fallback**: Look for `*::PP` modules or fallback patterns +3. **Test installation**: `./jcpan -t ModuleName` +4. **Document blockers**: Create/update design doc if issues found +5. **Consider Java XS**: For critical modules, implement in Java + +## Related Resources + +- [AGENTS.md](../../AGENTS.md) - Project guidelines +- [docs/guides/module-porting.md](../../docs/guides/module-porting.md) - User-facing porting guide +- `.cognition/skills/port-cpan-module/` - AI skill for porting modules + +## Document Index + +### Core Infrastructure +- [xsloader.md](xsloader.md) - XSLoader implementation +- [dynaloader.md](dynaloader.md) - DynaLoader architecture +- [dynamic_loading.md](dynamic_loading.md) - Dynamic module loading +- [makemaker_perlonjava.md](makemaker_perlonjava.md) - MakeMaker for PerlOnJava +- [cpan_client.md](cpan_client.md) - jcpan CPAN client + +### XS and Fallbacks +- [xs_fallback.md](xs_fallback.md) - XS fallback mechanism +- [pure-perl-exporter.md](pure-perl-exporter.md) - Pure Perl Exporter + +### Specific Modules +- [moose_support.md](moose_support.md) - Moose support (in progress) +- [moo_support.md](moo_support.md) - Moo support (working) +- [JCPAN_DATETIME_FIXES.md](JCPAN_DATETIME_FIXES.md) - DateTime via jcpan +- [log4perl-compatibility.md](log4perl-compatibility.md) - Log::Log4perl +- [term_readkey.md](term_readkey.md) - Term::ReadKey diff --git a/dev/design/cpan_client.md b/dev/modules/cpan_client.md similarity index 99% rename from dev/design/cpan_client.md rename to dev/modules/cpan_client.md index f3f5bb8fa..ae68b04f1 100644 --- a/dev/design/cpan_client.md +++ b/dev/modules/cpan_client.md @@ -409,7 +409,7 @@ The fix allows CPAN::Meta::YAML to properly parse MYMETA.yml files, enabling CPA ## Related Documents -- `dev/design/xsloader.md` - XSLoader/Java integration -- `dev/design/makemaker_perlonjava.md` - ExtUtils::MakeMaker implementation +- `xsloader.md` - XSLoader/Java integration +- `makemaker_perlonjava.md` - ExtUtils::MakeMaker implementation - `.cognition/skills/port-cpan-module/` - Skill for porting CPAN modules - `docs/guides/using-cpan-modules.md` - User documentation diff --git a/dev/design/dynaloader.md b/dev/modules/dynaloader.md similarity index 100% rename from dev/design/dynaloader.md rename to dev/modules/dynaloader.md diff --git a/dev/design/dynamic_loading.md b/dev/modules/dynamic_loading.md similarity index 100% rename from dev/design/dynamic_loading.md rename to dev/modules/dynamic_loading.md diff --git a/dev/design/log4perl-compatibility.md b/dev/modules/log4perl-compatibility.md similarity index 99% rename from dev/design/log4perl-compatibility.md rename to dev/modules/log4perl-compatibility.md index f42425c58..e4158e501 100644 --- a/dev/design/log4perl-compatibility.md +++ b/dev/modules/log4perl-compatibility.md @@ -187,7 +187,7 @@ BEGIN failed--compilation aborted at -e line 1, near "" - `src/main/java/org/perlonjava/backend/jvm/EmitSubroutine.java` - `src/main/java/org/perlonjava/runtime/runtimetypes/ExceptionFormatter.java` -**Design Document:** `dev/design/caller_line_number_fix.md` +**Design Document:** `../design/caller_line_number_fix.md` ### Issue 2: Stack Trace Format (%T) - FIXED diff --git a/dev/design/makemaker_perlonjava.md b/dev/modules/makemaker_perlonjava.md similarity index 99% rename from dev/design/makemaker_perlonjava.md rename to dev/modules/makemaker_perlonjava.md index 8f56a6a1a..40c862be8 100644 --- a/dev/design/makemaker_perlonjava.md +++ b/dev/modules/makemaker_perlonjava.md @@ -335,6 +335,6 @@ jperl Makefile.PL ## Related Documents -- `dev/design/cpan_client.md` - CPAN client status +- `cpan_client.md` - CPAN client status - `docs/guides/module-porting.md` - Module porting guide - `.cognition/skills/port-cpan-module/` - Port CPAN module skill diff --git a/dev/design/moo_support.md b/dev/modules/moo_support.md similarity index 98% rename from dev/design/moo_support.md rename to dev/modules/moo_support.md index 7a89b4e60..2d83e5121 100644 --- a/dev/design/moo_support.md +++ b/dev/modules/moo_support.md @@ -625,7 +625,7 @@ Moo tests run via `jcpan -t Moo`. Recent fixes (Phases 12-13) should improve pas - Modified `setDebugInfoLineNumber()` to also call `saveSourceLocation()` - This is called during emit when we have correct package context from the subroutine's symbol table - The emit-time call overwrites parse-time entries with correct package - - See `dev/design/caller_package_context.md` for detailed analysis + - See `../design/caller_package_context.md` for detailed analysis - No data structure changes, minimal 6-line fix - [x] Phase 29: Fix caller() returning wrong line numbers (2026-03-17) @@ -654,7 +654,7 @@ Moo tests run via `jcpan -t Moo`. Recent fixes (Phases 12-13) should improve pas - **ExceptionFormatter.java fix**: - Interpreter path now calls `ByteCodeSourceMapper.getPackageAtLocation()` for all frames - Ensures consistent package reporting regardless of stack depth - - See `dev/design/unified_caller_stack.md` for full analysis + - See `../design/unified_caller_stack.md` for full analysis - Result: Interpreter and JVM backends now report same package for same source location - [x] Phase 37: Fix #line directive to update errorUtil.fileName during parsing (2026-03-17) @@ -699,7 +699,7 @@ The remaining test failures require implementing core Perl features that are cur #### Phase 31: DESTROY/Destructor Support (High Impact) **Enables**: demolish tests (6 failures), proper object cleanup **Status**: Analysis complete, implementation deferred -**Design doc**: `dev/design/object_lifecycle.md` +**Design doc**: `../design/object_lifecycle.md` Perl's DESTROY relies on reference counting; Java uses GC. The challenge is detecting when an object becomes unreachable while we can still access it to call DESTROY. @@ -710,7 +710,7 @@ detailed analysis of implementation strategies, challenges, and test cases. #### Phase 32: Weak Reference Emulation (High Impact) **Enables**: accessor-weaken tests (20 failures), no-moo.t (5 failures) **Status**: Analysis complete, implementation deferred -**Design doc**: `dev/design/object_lifecycle.md` +**Design doc**: `../design/object_lifecycle.md` Perl's weak references are tied to reference counting, which Java doesn't have. @@ -754,7 +754,7 @@ The interpreter path was using different package sources for inner vs outer fram Fixed by adding `getPackageAtLocation()` to ByteCodeSourceMapper and using it in ExceptionFormatter for all frames. -See `dev/design/unified_caller_stack.md` for detailed analysis. +See `../design/unified_caller_stack.md` for detailed analysis. #### Phase 35: Mo strict.t - Make $^H Magical (Completed) **Enables**: Mo t/strict.t (1 failure) → **FIXED** @@ -768,7 +768,7 @@ that didn't communicate with the compiler's strict checking. - On read: Returns current strict options from symbol table **Future consideration**: Refactor to use `$^H` as single source of truth, eliminating -`strictOptionsStack`. See `dev/design/strict_hints_refactor.md` for analysis. +`strictOptionsStack`. See `../design/strict_hints_refactor.md` for analysis. **Result**: Mo tests now 28/28 passing (was 27/28). @@ -824,7 +824,7 @@ which are fundamentally limited by Java's GC model. ## Related Documents -- `dev/design/cpan_client.md` - jcpan implementation -- `dev/design/unified_caller_stack.md` - caller() package tracking analysis +- `cpan_client.md` - jcpan implementation +- `../design/unified_caller_stack.md` - caller() package tracking analysis - `dev/import-perl5/README.md` - Module sync process - `dev/import-perl5/config.yaml` - Module import configuration diff --git a/dev/modules/moose_support.md b/dev/modules/moose_support.md new file mode 100644 index 000000000..97ec477f6 --- /dev/null +++ b/dev/modules/moose_support.md @@ -0,0 +1,402 @@ +# Moose Support for PerlOnJava + +## Overview + +This document outlines the path to supporting Moose (and Class::MOP) on PerlOnJava. Moose is Perl's most popular object system, providing a rich meta-object protocol (MOP) for defining classes, attributes, roles, and more. + +## Current Status: Not Feasible (Requires Phase 1) + +### Blockers + +| Blocker | Severity | Description | +|---------|----------|-------------| +| Subroutine name introspection | **Critical** | `B::CV->GV->NAME` returns `__ANON__` for named subs | +| Makefile.PL compiler check | Medium | `ExtUtils::HasCompiler` dies without compiler | +| Class::MOP XS functions | Medium | No pure Perl fallbacks provided | +| MAGIC-based export tracking | Low | XS uses sv_magic for export flags | + +### What Already Works + +| Component | Status | Notes | +|-----------|--------|-------| +| Moo | **96% tests pass** | Recommended alternative | +| Params::Util | Works | Requires `PERL_PARAMS_UTIL_PP=1` | +| Package::Stash | Works | Uses PP fallback automatically | +| Class::Load | Works | Uses PP fallback automatically | +| Data::OptList | Works | With Params::Util PP mode | +| Sub::Install | Mostly works | Some test failures | + +--- + +## Root Cause Analysis + +### The Subroutine Name Problem + +When Perl compiles `sub foo { ... }`, it stores metadata about the subroutine: +- Package name (stash) +- Subroutine name +- File and line number + +This metadata is accessible via the B (Perl internals) module: + +```perl +sub foo { 1 } +use B; +my $cv = B::svref_2object(\&foo); +print $cv->GV->NAME; # Should print "foo" +print $cv->GV->STASH->NAME; # Should print "main" +``` + +**Current PerlOnJava behavior:** +``` +Name: __ANON__ +Stash: main +``` + +**Expected behavior:** +``` +Name: foo +Stash: main +``` + +### Why This Matters for Moose + +Moose uses `Class::MOP::get_code_info($coderef)` extensively: + +1. **Method tracking**: Determining if a method belongs to a class or was imported +2. **Role application**: Checking method origins during role composition +3. **Export management**: Tracking which subs were exported vs. defined locally +4. **Metaclass operations**: Building method maps, checking overrides + +Without accurate subroutine name introspection, Moose cannot function correctly. + +--- + +## Implementation Plan + +### Phase 1: Fix B Module Subroutine Name Introspection (Critical) + +**Goal**: Make `B::CV->GV->NAME` return the actual subroutine name. + +**Analysis Required**: + +1. **Where subroutine names are stored**: + - Check `RuntimeCode.java` - does it store the subroutine name? + - Check `EmitterMethodCreator.java` - is the name passed during creation? + - Check symbol table operations in `GlobalVariable.java` + +2. **Where B module queries names**: + - `src/main/java/org/perlonjava/perlmodule/B.java` + - Methods: `BCV`, `BGV`, `BSTASH` + +**Likely Fix**: + +The `RuntimeCode` class needs to store the subroutine name when created: + +```java +// RuntimeCode.java +public class RuntimeCode { + private String subName; // Add this field + private String packageName; // Add this field + + public String getSubName() { + return subName != null ? subName : "__ANON__"; + } + + public String getPackageName() { + return packageName != null ? packageName : "main"; + } +} +``` + +Then update the B module to query these: + +```java +// B.java - in the GV NAME accessor +public static RuntimeScalar getName(RuntimeScalar self) { + RuntimeCode code = (RuntimeCode) self.value; + return new RuntimeScalar(code.getSubName()); +} +``` + +**Files to investigate**: +- `src/main/java/org/perlonjava/runtime/RuntimeCode.java` +- `src/main/java/org/perlonjava/perlmodule/B.java` +- `src/main/java/org/perlonjava/codegen/EmitterMethodCreator.java` +- `src/main/java/org/perlonjava/runtime/GlobalVariable.java` + +**Test**: +```perl +sub named_sub { 42 } +use B; +my $cv = B::svref_2object(\&named_sub); +print $cv->GV->NAME eq 'named_sub' ? "ok" : "not ok"; +print $cv->GV->STASH->NAME eq 'main' ? "ok" : "not ok"; +``` + +--- + +### Phase 2: Bypass Makefile.PL Compiler Check + +**Goal**: Allow Moose to install despite lacking a C compiler. + +**Options**: + +#### Option A: Patch ExtUtils::HasCompiler (Recommended) + +Create a PerlOnJava-specific version that returns false gracefully: + +```perl +# src/main/perl/lib/ExtUtils/HasCompiler.pm +package ExtUtils::HasCompiler; +use strict; +use warnings; + +sub can_compile_loadable_object { + # PerlOnJava cannot compile XS, but modules may have PP fallbacks + return 0; +} + +# ... rest of API for compatibility +``` + +#### Option B: Environment Variable + +Set `PERLONJAVA_SKIP_XS_CHECK=1` and patch Moose's Makefile.PL detection. + +#### Option C: jcpan Patching + +Have jcpan automatically patch known modules during installation. + +**Files to create/modify**: +- `src/main/perl/lib/ExtUtils/HasCompiler.pm` + +--- + +### Phase 3: Implement Class::MOP Java XS Functions + +**Goal**: Provide Java implementations for critical MOP functions. + +**Functions to implement**: + +| Function | Purpose | Complexity | +|----------|---------|------------| +| `get_code_info` | Get package/name from coderef | Easy (after Phase 1) | +| `INSTALL_SIMPLE_READER` | Create hash accessor methods | Medium | +| `is_stub` | Check if method is a stub | Easy | +| `_flag_as_reexport` | Mark glob as re-export | Hard (needs MAGIC) | +| `_export_is_flagged` | Check re-export flag | Hard (needs MAGIC) | + +**Implementation approach**: + +Create `src/main/java/org/perlonjava/perlmodule/ClassMOP.java`: + +```java +package org.perlonjava.perlmodule; + +public class ClassMOP extends PerlModuleBase { + + public ClassMOP() { + super("Class::MOP", false); + } + + public static void initialize() { + ClassMOP module = new ClassMOP(); + try { + module.registerMethod("get_code_info", null); + } catch (NoSuchMethodException e) { + // handle + } + } + + /** + * get_code_info($coderef) + * Returns (package_name, sub_name) for a code reference. + */ + public static RuntimeList get_code_info(RuntimeArray args, int ctx) { + RuntimeScalar coderef = args.get(0); + if (coderef.type != RuntimeScalarType.CODE) { + return new RuntimeList(); + } + + RuntimeCode code = (RuntimeCode) coderef.value; + RuntimeList result = new RuntimeList(); + result.add(new RuntimeScalar(code.getPackageName())); + result.add(new RuntimeScalar(code.getSubName())); + return result; + } +} +``` + +**Files to create**: +- `src/main/java/org/perlonjava/perlmodule/ClassMOP.java` + +--- + +### Phase 4: Handle Export Flag Magic (Optional) + +**Goal**: Implement MAGIC-based export tracking for Moose::Exporter. + +This is lower priority because: +1. It only affects re-export detection +2. Moose may work without it (with some export warnings) + +**If needed**, implement a simplified version using a WeakHashMap in Java to track flagged globs. + +--- + +### Phase 5: Testing and Validation + +**Test progression**: + +1. **Unit tests for B module fixes**: + ```bash + ./jperl -e 'sub foo{} use B; print B::svref_2object(\&foo)->GV->NAME' + ``` + +2. **Sub::Identify tests**: + ```bash + PERL_PARAMS_UTIL_PP=1 ./jcpan -t Sub::Identify + ``` + +3. **Class::Load with Moose dependencies**: + ```bash + PERL_PARAMS_UTIL_PP=1 ./jperl -e 'use Class::Load qw(load_class); load_class("Moose"); print "ok\n"' + ``` + +4. **Basic Moose functionality**: + ```perl + use Moose; + + has 'name' => (is => 'ro', isa => 'Str'); + + my $obj = __PACKAGE__->new(name => 'test'); + print $obj->name; + ``` + +5. **Full Moose test suite**: + ```bash + ./jcpan -t Moose + ``` + +--- + +## Alternative: Use Moo + +If Moose support proves too complex, **Moo is already working** and provides most functionality: + +```perl +package MyClass; +use Moo; + +has name => (is => 'ro', isa => sub { die unless defined $_[0] }); +has age => (is => 'rw', default => sub { 0 }); + +sub greet { + my $self = shift; + return "Hello, " . $self->name; +} + +1; +``` + +**Moo features that work**: +- Attributes with `is`, `isa`, `default`, `trigger`, `coerce` +- Inheritance with `extends` +- Roles with `Role::Tiny` / `Moo::Role` +- Method modifiers (`before`, `after`, `around`) +- BUILD and BUILDARGS + +**Moo limitations on PerlOnJava** (expected): +- Weak references don't behave like native Perl +- DEMOLISH timing differs (JVM GC) +- Some namespace cleanup edge cases + +--- + +## Dependencies Graph + +``` +Moose +├── Class::MOP (XS - needs Java impl) +│ └── MRO::Compat (works) +├── Class::Load (works with PP) +│ ├── Data::OptList (works) +│ │ ├── Params::Util (needs PERL_PARAMS_UTIL_PP=1) +│ │ └── Sub::Install (mostly works) +│ └── Package::Stash (works with PP) +├── Devel::GlobalDestruction (works) +├── Devel::OverloadInfo (needs investigation) +├── Devel::StackTrace (works) +├── Dist::CheckConflicts (works) +├── Eval::Closure (needs investigation) +├── List::Util (built-in) +├── Module::Runtime (works) +├── Package::DeprecationManager (needs investigation) +├── Params::Util (needs PP flag) +├── Scalar::Util (built-in) +├── Sub::Exporter (needs investigation) +└── Try::Tiny (works) +``` + +--- + +## Environment Variables for PP Mode + +Until Java XS is implemented, use these environment variables: + +```bash +export PERL_PARAMS_UTIL_PP=1 +# Future: export PERL_CLASS_MOP_PP=1 +``` + +Or create a wrapper script: + +```bash +#!/bin/bash +# jperl-moose - Run jperl with Moose-compatible settings +export PERL_PARAMS_UTIL_PP=1 +exec jperl "$@" +``` + +--- + +## Progress Tracking + +### Current Status: Phase 0 - Investigation Complete + +### Completed +- [x] Investigation of Moose requirements (2025-03-27) +- [x] Identified root cause: B module subroutine names +- [x] Verified Moo works as alternative (96% tests pass) +- [x] Documented dependency tree and status + +### Next Steps +1. [ ] Phase 1: Fix B module subroutine name introspection +2. [ ] Phase 2: Create ExtUtils::HasCompiler stub +3. [ ] Phase 3: Implement Class::MOP Java XS +4. [ ] Phase 4: Handle export flag magic (if needed) +5. [ ] Phase 5: Full Moose test suite + +### Open Questions +- Should we prioritize Moose or focus on Moo compatibility? +- Is there demand for full Moose metaclass introspection? +- Can we implement a "Moose-lite" that covers common use cases? + +--- + +## Related Documents + +- [xs_fallback.md](xs_fallback.md) - XS fallback mechanism +- [makemaker_perlonjava.md](makemaker_perlonjava.md) - MakeMaker implementation +- [cpan_client.md](cpan_client.md) - CPAN client support +- `.cognition/skills/port-cpan-module/` - Module porting skill + +--- + +## References + +- [Moose Manual](https://metacpan.org/pod/Moose::Manual) +- [Class::MOP](https://metacpan.org/pod/Class::MOP) +- [Moo](https://metacpan.org/pod/Moo) - Minimalist Object Orientation +- [B module](https://perldoc.perl.org/B) - Perl compiler backend diff --git a/dev/design/pure-perl-exporter.md b/dev/modules/pure-perl-exporter.md similarity index 100% rename from dev/design/pure-perl-exporter.md rename to dev/modules/pure-perl-exporter.md diff --git a/dev/design/term_readkey.md b/dev/modules/term_readkey.md similarity index 100% rename from dev/design/term_readkey.md rename to dev/modules/term_readkey.md diff --git a/dev/design/xs_fallback.md b/dev/modules/xs_fallback.md similarity index 99% rename from dev/design/xs_fallback.md rename to dev/modules/xs_fallback.md index cffd79d08..f3b3000d0 100644 --- a/dev/design/xs_fallback.md +++ b/dev/modules/xs_fallback.md @@ -751,9 +751,9 @@ modules: ## Related Documents -- `dev/design/xsloader.md` - XSLoader architecture -- `dev/design/makemaker_perlonjava.md` - MakeMaker implementation -- `dev/design/cpan_client.md` - CPAN client support +- `xsloader.md` - XSLoader architecture +- `makemaker_perlonjava.md` - MakeMaker implementation +- `cpan_client.md` - CPAN client support - `.cognition/skills/port-cpan-module/` - Module porting skill --- diff --git a/dev/design/xsloader.md b/dev/modules/xsloader.md similarity index 100% rename from dev/design/xsloader.md rename to dev/modules/xsloader.md diff --git a/src/main/java/org/perlonjava/core/Configuration.java b/src/main/java/org/perlonjava/core/Configuration.java index 06592f092..343ee3590 100644 --- a/src/main/java/org/perlonjava/core/Configuration.java +++ b/src/main/java/org/perlonjava/core/Configuration.java @@ -33,7 +33,7 @@ public final class Configuration { * Automatically populated by Gradle/Maven during build. * DO NOT EDIT MANUALLY - this value is replaced at build time. */ - public static final String gitCommitId = "9153c9ba8"; + public static final String gitCommitId = "6514d90c2"; /** * Git commit date of the build (ISO format: YYYY-MM-DD).