Enhance test coverage and update dependencies for development

.github/workflows/maven-publish.yml

@@ -14,9 +14,9 @@ on:
   workflow_dispatch:
     inputs:
       revision:
-        description: 'The version to release'
+        description: 'The version to publish (must match ${major}.${minor}.${patch})'
         required: true
-        default: '0.0.1-SNAPSHOT'
+        default: '${major}.${minor}.${patch}'
 
 jobs:
   build:
@@ -26,6 +26,13 @@ jobs:
       - name: Checkout Source
         uses: actions/checkout@v5
 
+      - name: Validate version format
+        run: |
+          if ! echo "${{ inputs.revision }}" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+            echo "Error: version '${{ inputs.revision }}' does not match the required pattern major.minor.patch"
+            exit 1
+          fi
+
       - name: Setup Maven Central Repository
         uses: actions/setup-java@v5
         with:
@@ -51,3 +58,57 @@ jobs:
           SIGN_KEY_ID: ${{ secrets.OSS_SIGNING_KEY_ID_LONG }}
           SIGN_KEY: ${{ secrets.OSS_SIGNING_KEY }}
           SIGN_KEY_PASS: ${{ secrets.OSS_SIGNING_PASSWORD }}
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout Source
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Create Tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if git rev-parse "${{ inputs.revision }}" >/dev/null 2>&1; then
+            echo "Tag ${{ inputs.revision }} already exists, skipping."
+          else
+            git tag ${{ inputs.revision }}
+            git push origin ${{ inputs.revision }}
+          fi
+
+      - name: Create Release
+        run: |
+          if gh release view "v${{ inputs.revision }}" >/dev/null 2>&1; then
+            echo "Release v${{ inputs.revision }} already exists, skipping."
+          else
+            gh release create v${{ inputs.revision }} \
+              --title "v${{ inputs.revision }}" \
+              --generate-notes \
+              --latest
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Increment patch version
+        run: |
+          CURRENT="${{ inputs.revision }}"
+          MAJOR=$(echo "$CURRENT" | cut -d. -f1)
+          MINOR=$(echo "$CURRENT" | cut -d. -f2)
+          PATCH=$(echo "$CURRENT" | cut -d. -f3)
+          NEXT_PATCH=$((PATCH + 1))
+          NEXT_VERSION="${MAJOR}.${MINOR}.${NEXT_PATCH}-SNAPSHOT"
+          sed -i "s|^\( *\)<revision>[^<]*</revision>|\1<revision>${NEXT_VERSION}</revision>|" pom.xml
+          echo "Bumped version from ${CURRENT} to ${NEXT_VERSION}"
+
+      - name: Commit and push next version
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pom.xml
+          git diff --cached --quiet && echo "No changes to commit" || \
+            git commit -m "chore: bump version to next patch after publishing ${{ inputs.revision }}" && git push

.github/workflows/merge-main-to-branches.yml

@@ -0,0 +1,66 @@
+# This workflow automatically merges the 'main' branch into 'dev' and 'release' branches
+# whenever changes are pushed to 'main', without requiring manual confirmation.
+
+name: Merge Main to Dev and Release
+
+on:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: merge-main-to-branches
+  cancel-in-progress: false
+
+jobs:
+  merge-to-dev:
+    name: Merge main → dev
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Merge main into dev
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if ! git checkout dev; then
+            echo "::error::Branch 'dev' does not exist. Skipping merge."
+            exit 1
+          fi
+          if ! git merge --no-ff origin/main -m "chore: merge main into dev [skip ci]"; then
+            echo "::error::Merge conflict detected when merging main into dev. Manual intervention required."
+            exit 1
+          fi
+          git push origin dev
+
+  merge-to-release:
+    name: Merge main → release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Merge main into release
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if ! git checkout release; then
+            echo "::error::Branch 'release' does not exist. Skipping merge."
+            exit 1
+          fi
+          if ! git merge --no-ff origin/main -m "chore: merge main into release [skip ci]"; then
+            echo "::error::Merge conflict detected when merging main into release. Manual intervention required."
+            exit 1
+          fi
+          git push origin release

microsphere-java-core/src/main/java/io/microsphere/collection/Lists.java

@@ -117,11 +117,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList() {
-        if (of0MethodHandle == null) {
+        return ofList0(of0MethodHandle);
+    }
+
+    static <E> List<E> ofList0(MethodHandle methodHandle) {
+        if (methodHandle == null) {
             return emptyList();
         }
         try {
-            return (List<E>) of0MethodHandle.invokeExact();
+            return (List<E>) methodHandle.invokeExact();
         } catch (Throwable e) {
             return emptyList();
         }
@@ -146,11 +150,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1) {
-        if (of1MethodHandle == null) {
+        return ofList1(of1MethodHandle, e1);
+    }
+
+    static <E> List<E> ofList1(MethodHandle methodHandle, E e1) {
+        if (methodHandle == null) {
             return singletonList(e1);
         }
         try {
-            return (List<E>) of1MethodHandle.invokeExact(e1);
+            return (List<E>) methodHandle.invokeExact(e1);
         } catch (Throwable e) {
             return singletonList(e1);
         }
@@ -176,11 +184,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2) {
-        if (of2MethodHandle == null) {
+        return ofList2(of2MethodHandle, e1, e2);
+    }
+
+    static <E> List<E> ofList2(MethodHandle methodHandle, E e1, E e2) {
+        if (methodHandle == null) {
             return of(e1, e2);
         }
         try {
-            return (List<E>) of2MethodHandle.invokeExact(e1, e2);
+            return (List<E>) methodHandle.invokeExact(e1, e2);
         } catch (Throwable e) {
             return of(e1, e2);
         }
@@ -207,11 +219,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3) {
-        if (of3MethodHandle == null) {
+        return ofList3(of3MethodHandle, e1, e2, e3);
+    }
+
+    static <E> List<E> ofList3(MethodHandle methodHandle, E e1, E e2, E e3) {
+        if (methodHandle == null) {
             return of(e1, e2, e3);
         }
         try {
-            return (List<E>) of3MethodHandle.invokeExact(e1, e2, e3);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3);
         } catch (Throwable e) {
             return of(e1, e2, e3);
         }
@@ -239,11 +255,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3, E e4) {
-        if (of4MethodHandle == null) {
+        return ofList4(of4MethodHandle, e1, e2, e3, e4);
+    }
+
+    static <E> List<E> ofList4(MethodHandle methodHandle, E e1, E e2, E e3, E e4) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4);
         }
         try {
-            return (List<E>) of4MethodHandle.invokeExact(e1, e2, e3, e4);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4);
         }
@@ -272,11 +292,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5) {
-        if (of5MethodHandle == null) {
+        return ofList5(of5MethodHandle, e1, e2, e3, e4, e5);
+    }
+
+    static <E> List<E> ofList5(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5);
         }
         try {
-            return (List<E>) of5MethodHandle.invokeExact(e1, e2, e3, e4, e5);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5);
         }
@@ -298,11 +322,15 @@
     @Nonnull
     @Immutable
     static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5, E e6) {
-        if (of6MethodHandle == null) {
+        return ofList6(of6MethodHandle, e1, e2, e3, e4, e5, e6);
+    }
+
+    static <E> List<E> ofList6(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5, E e6) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5, e6);
         }
         try {
-            return (List<E>) of6MethodHandle.invokeExact(e1, e2, e3, e4, e5, e6);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5, e6);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5, e6);
         }
@@ -333,11 +361,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
-        if (of7MethodHandle == null) {
+        return ofList7(of7MethodHandle, e1, e2, e3, e4, e5, e6, e7);
+    }
+
+    static <E> List<E> ofList7(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5, e6, e7);
         }
         try {
-            return (List<E>) of7MethodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5, e6, e7);
         }
@@ -369,11 +401,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
-        if (of8MethodHandle == null) {
+        return ofList8(of8MethodHandle, e1, e2, e3, e4, e5, e6, e7, e8);
+    }
+
+    static <E> List<E> ofList8(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8);
         }
         try {
-            return (List<E>) of8MethodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8);
         }
@@ -406,11 +442,15 @@
     @Nonnull
     @Immutable
     public static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
-        if (of9MethodHandle == null) {
+        return ofList9(of9MethodHandle, e1, e2, e3, e4, e5, e6, e7, e8, e9);
+    }
+
+    static <E> List<E> ofList9(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8, e9);
         }
         try {
-            return (List<E>) of9MethodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8, e9);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8, e9);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8, e9);
         }
@@ -436,11 +476,15 @@
     @Nonnull
     @Immutable
     static <E> List<E> ofList(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
-        if (of10MethodHandle == null) {
+        return ofList10(of10MethodHandle, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
+    }
+
+    static <E> List<E> ofList10(MethodHandle methodHandle, E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
+        if (methodHandle == null) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
         }
         try {
-            return (List<E>) of10MethodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
+            return (List<E>) methodHandle.invokeExact(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
         } catch (Throwable e) {
             return of(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);
         }
@@ -470,11 +514,15 @@
         if (length(elements) < 1) {
             return ofList();
         }
-        if (ofMethodHandle == null) {
+        return ofListElements(ofMethodHandle, elements);
+    }
+
+    static <E> List<E> ofListElements(MethodHandle methodHandle, E[] elements) {
+        if (methodHandle == null) {
             return of(elements);
         }
         try {
-            return (List<E>) ofMethodHandle.invokeExact(elements);
+            return (List<E>) methodHandle.invokeExact(elements);
         } catch (Throwable e) {
             return of(elements);
         }