chore: make arrow to report dynamic version

Author: norberttech

.github/workflows/job-arrow-extension.yml

@@ -82,11 +82,3 @@ jobs:
 
       - name: Run Parquet Integration Tests with Arrow
         run: composer test:lib:parquet
-
-      - name: Upload to Codecov
-        if: ${{ !cancelled() && matrix.php == '8.3' }}
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          directory: ./var/phpunit/coverage/clover
-          flags: arrow-extension

.nix/pkgs/php-arrow-ext/package.nix

@@ -5,6 +5,7 @@
   rustPlatform,
   clang,
   llvmPackages,
+  arrow-ext-version ? "dev",
 }:
 
 let
@@ -25,7 +26,7 @@ let
   };
   pkg = rustPlatform.buildRustPackage {
     pname = "php-arrow-ext";
-    version = "0.1.0";
+    version = arrow-ext-version;
 
     src = extSrc;
 
@@ -42,6 +43,7 @@ let
       LIBCLANG_PATH = "${llvmPackages.libclang.lib}/lib";
       PHP_CONFIG = "${php.unwrapped.dev}/bin/php-config";
       PHP = "${php.unwrapped}/bin/php";
+      ARROW_VERSION = arrow-ext-version;
     };
 
     installPhase = let

src/extension/arrow-ext/build.rs

@@ -0,0 +1,42 @@
+fn main() {
+    let version = std::env::var("ARROW_VERSION")
+        .ok()
+        .filter(|s| !s.is_empty())
+        .or_else(|| {
+            std::process::Command::new("git")
+                .args(["describe", "--tags", "--always"])
+                .output()
+                .ok()
+                .filter(|o| o.status.success())
+                .and_then(|o| String::from_utf8(o.stdout).ok())
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+        })
+        .unwrap_or_else(|| env!("CARGO_PKG_VERSION").to_string());
+
+    println!("cargo:rustc-env=ARROW_VERSION={version}");
+
+    let arrow_version = resolve_dep_version("arrow-schema").unwrap_or_else(|| "unknown".to_string());
+    let parquet_version = resolve_dep_version("parquet").unwrap_or_else(|| "unknown".to_string());
+
+    println!("cargo:rustc-env=ARROW_LIB_VERSION={arrow_version}");
+    println!("cargo:rustc-env=PARQUET_LIB_VERSION={parquet_version}");
+}
+
+fn resolve_dep_version(crate_name: &str) -> Option<String> {
+    let lock_contents = std::fs::read_to_string("Cargo.lock").ok()?;
+    let needle = format!("name = \"{crate_name}\"");
+
+    for chunk in lock_contents.split("[[package]]") {
+        if chunk.contains(&needle) {
+            for line in chunk.lines() {
+                let line = line.trim();
+                if line.starts_with("version = ") {
+                    return Some(line.trim_start_matches("version = ").trim_matches('"').to_string());
+                }
+            }
+        }
+    }
+
+    None
+}

src/extension/arrow-ext/src/lib.rs

@@ -14,8 +14,10 @@ static GLOBAL: System = System;
 
 pub extern "C" fn php_module_info(_module: *mut ModuleEntry) {
     info_table_start!();
-    info_table_row!("arrow", "enabled");
-    info_table_row!("version", env!("CARGO_PKG_VERSION"));
+    info_table_row!("arrow.enabled", "true");
+    info_table_row!("arrow.extension_version", env!("ARROW_VERSION"));
+    info_table_row!("arrow.library_version", env!("ARROW_LIB_VERSION"));
+    info_table_row!("arrow.parquet_library_version", env!("PARQUET_LIB_VERSION"));
     info_table_end!();
 }
 

src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/AdaptiveParquetEngineTest.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine;
+
+use Flow\Parquet\Engine\{AdaptiveParquetEngine, ArrowParquetEngine, PhpParquetEngine};
+use PHPUnit\Framework\TestCase;
+
+final class AdaptiveParquetEngineTest extends TestCase
+{
+    public function test_creates_arrow_engine_when_arrow_extension_loaded() : void
+    {
+        if (!\extension_loaded('arrow')) {
+            self::markTestSkipped('This test requires the arrow extension to be loaded');
+        }
+
+        $engine = new AdaptiveParquetEngine();
+
+        $reflection = new \ReflectionClass($engine);
+        $delegate = $reflection->getProperty('delegate')->getValue($engine);
+
+        self::assertInstanceOf(ArrowParquetEngine::class, $delegate);
+    }
+
+    public function test_creates_php_engine_when_arrow_extension_not_loaded() : void
+    {
+        if (\extension_loaded('arrow')) {
+            self::markTestSkipped('This test requires the arrow extension to NOT be loaded');
+        }
+
+        $engine = new AdaptiveParquetEngine();
+
+        $reflection = new \ReflectionClass($engine);
+        $delegate = $reflection->getProperty('delegate')->getValue($engine);
+
+        self::assertInstanceOf(PhpParquetEngine::class, $delegate);
+    }
+}

src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/DestinationStreamAdapterTest.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine\Arrow;
+
+use Flow\Filesystem\Local\Memory\MemoryStream;
+use Flow\Filesystem\Path;
+use Flow\Parquet\Engine\Arrow\DestinationStreamAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class DestinationStreamAdapterTest extends TestCase
+{
+    public function test_append_delegates_to_destination_stream() : void
+    {
+        $handle = \fopen('php://memory', 'r+b');
+        $stream = new MemoryStream($handle, Path::realpath('/tmp/test'));
+
+        $adapter = new DestinationStreamAdapter($stream);
+        $adapter->append('hello ');
+        $adapter->append('world');
+
+        self::assertSame('hello world', $stream->content());
+    }
+
+    public function test_append_returns_self() : void
+    {
+        $handle = \fopen('php://memory', 'r+b');
+        $stream = new MemoryStream($handle, Path::realpath('/tmp/test'));
+
+        $adapter = new DestinationStreamAdapter($stream);
+
+        self::assertSame($adapter, $adapter->append('data'));
+    }
+}

src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/SourceStreamAdapterTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine\Arrow;
+
+use Flow\Filesystem\Local\Memory\MemoryStream;
+use Flow\Filesystem\Path;
+use Flow\Parquet\Engine\Arrow\SourceStreamAdapter;
+use PHPUnit\Framework\TestCase;
+
+final class SourceStreamAdapterTest extends TestCase
+{
+    public function test_read_delegates_to_source_stream() : void
+    {
+        $handle = \fopen('php://memory', 'r+b');
+        \fwrite($handle, 'hello world');
+        $stream = new MemoryStream($handle, Path::realpath('/tmp/test'));
+
+        $adapter = new SourceStreamAdapter($stream);
+
+        self::assertSame('hello', $adapter->read(5, 0));
+        self::assertSame('world', $adapter->read(5, 6));
+        self::assertSame(' ', $adapter->read(1, 5));
+    }
+
+    public function test_size_delegates_to_source_stream() : void
+    {
+        $handle = \fopen('php://memory', 'r+b');
+        \fwrite($handle, 'hello world');
+        $stream = new MemoryStream($handle, Path::realpath('/tmp/test'));
+
+        $adapter = new SourceStreamAdapter($stream);
+
+        self::assertSame(11, $adapter->size());
+    }
+}

src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/ArrowParquetEngineTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine;
+
+use Flow\Parquet\Engine\ArrowParquetEngine;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetFile\Compressions;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class ArrowParquetEngineTest extends TestCase
+{
+    public function test_constructor_throws_when_extension_not_loaded() : void
+    {
+        if (\extension_loaded('arrow')) {
+            self::markTestSkipped('This test requires the arrow extension to NOT be loaded');
+        }
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('arrow extension is required');
+
+        new ArrowParquetEngine();
+    }
+
+    #[TestWith([Compressions::UNCOMPRESSED, 'UNCOMPRESSED'])]
+    #[TestWith([Compressions::SNAPPY, 'SNAPPY'])]
+    #[TestWith([Compressions::GZIP, 'GZIP'])]
+    #[TestWith([Compressions::BROTLI, 'BROTLI'])]
+    #[TestWith([Compressions::LZ4, 'LZ4_RAW'])]
+    #[TestWith([Compressions::LZ4_RAW, 'LZ4_RAW'])]
+    #[TestWith([Compressions::ZSTD, 'ZSTD'])]
+    public function test_map_compression(Compressions $input, string $expected) : void
+    {
+        self::assertSame($expected, ArrowParquetEngine::mapCompression($input));
+    }
+
+    public function test_map_compression_throws_for_lzo() : void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('LZO compression is not supported');
+
+        ArrowParquetEngine::mapCompression(Compressions::LZO);
+    }
+}