mainframe-migration-toolkit 0.2.0__py3-none-any.whl

mainframe_toolkit/_workspace/validator-java/mvnw.cmd

@@ -0,0 +1,189 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

mainframe_toolkit/_workspace/validator-java/pom.xml

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>io.mainframe.migration</groupId>
+  <artifactId>dataset-validator</artifactId>
+  <version>0.1.0</version>
+  <name>dataset-validator</name>
+
+  <properties>
+    <maven.compiler.release>17</maven.compiler.release>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <jackson.version>2.21.3</jackson.version>
+    <junit.version>5.11.4</junit.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>info.picocli</groupId>
+      <artifactId>picocli</artifactId>
+      <version>4.7.7</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-csv</artifactId>
+      <version>1.14.1</version>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>${jackson.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.parquet</groupId>
+      <artifactId>parquet-avro</artifactId>
+      <version>1.17.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.hadoop</groupId>
+      <artifactId>hadoop-client-api</artifactId>
+      <version>3.3.6</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.hadoop</groupId>
+      <artifactId>hadoop-client-runtime</artifactId>
+      <version>3.3.6</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-nop</artifactId>
+      <version>1.7.36</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>${junit.version}</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <finalName>dataset-validator</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.14.0</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.5.2</version>
+        <configuration>
+          <useModulePath>false</useModulePath>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.6.1</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <createDependencyReducedPom>false</createDependencyReducedPom>
+              <shadedArtifactAttached>false</shadedArtifactAttached>
+              <filters>
+                <filter>
+                  <artifact>*:*</artifact>
+                  <excludes>
+                    <exclude>META-INF/*.SF</exclude>
+                    <exclude>META-INF/*.DSA</exclude>
+                    <exclude>META-INF/*.RSA</exclude>
+                  </excludes>
+                </filter>
+              </filters>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>io.mainframe.migration.validator.ValidatorCli</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/AvroValueFormatter.java

@@ -0,0 +1,152 @@
+package io.mainframe.migration.validator;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.MapperFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.avro.Conversions;
+import org.apache.avro.LogicalTypes;
+import org.apache.avro.Schema;
+import org.apache.avro.generic.GenericData;
+import org.apache.avro.generic.GenericFixed;
+import org.apache.avro.generic.GenericRecord;
+
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+final class AvroValueFormatter {
+    private static final ObjectMapper JSON = new ObjectMapper()
+            .enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
+
+    private AvroValueFormatter() {
+    }
+
+    static String format(Object value, Schema schema) {
+        if (value == null) {
+            return null;
+        }
+        Object canonical = canonical(value, resolveUnion(value, schema));
+        if (canonical instanceof BigDecimal decimal) {
+            return decimal.toPlainString();
+        }
+        if (canonical instanceof Map<?, ?> || canonical instanceof List<?>) {
+            try {
+                return JSON.writeValueAsString(canonical);
+            } catch (JsonProcessingException exception) {
+                throw new IllegalArgumentException("Não foi possível serializar valor Parquet", exception);
+            }
+        }
+        return String.valueOf(canonical);
+    }
+
+    private static Object canonical(Object value, Schema schema) {
+        if (value == null) {
+            return null;
+        }
+
+        if (schema != null && schema.getLogicalType() != null) {
+            Object logical = logicalValue(value, schema);
+            if (logical != null) {
+                return logical;
+            }
+        }
+        if (value instanceof GenericRecord record) {
+            Map<String, Object> result = new LinkedHashMap<>();
+            for (Schema.Field field : record.getSchema().getFields()) {
+                Object child = record.get(field.name());
+                result.put(field.name(), canonical(child, resolveUnion(child, field.schema())));
+            }
+            return result;
+        }
+        if (value instanceof Map<?, ?> map) {
+            Map<String, Object> result = new TreeMap<>();
+            Schema valueSchema = schema != null && schema.getType() == Schema.Type.MAP
+                    ? schema.getValueType()
+                    : null;
+            map.forEach((key, child) -> result.put(
+                    String.valueOf(key), canonical(child, resolveUnion(child, valueSchema))));
+            return result;
+        }
+        if (value instanceof Iterable<?> iterable) {
+            List<Object> result = new ArrayList<>();
+            Schema elementSchema = schema != null && schema.getType() == Schema.Type.ARRAY
+                    ? schema.getElementType()
+                    : null;
+            for (Object child : iterable) {
+                result.add(canonical(child, resolveUnion(child, elementSchema)));
+            }
+            return result;
+        }
+        if (value instanceof ByteBuffer buffer) {
+            ByteBuffer copy = buffer.duplicate();
+            byte[] bytes = new byte[copy.remaining()];
+            copy.get(bytes);
+            return Base64.getEncoder().encodeToString(bytes);
+        }
+        if (value instanceof GenericFixed fixed) {
+            return Base64.getEncoder().encodeToString(fixed.bytes());
+        }
+        if (value instanceof GenericData.EnumSymbol || value instanceof CharSequence) {
+            return value.toString();
+        }
+        return value;
+    }
+
+    private static Object logicalValue(Object value, Schema schema) {
+        String logicalType = schema.getLogicalType().getName();
+        if (schema.getLogicalType() instanceof LogicalTypes.Decimal decimal) {
+            Conversions.DecimalConversion conversion = new Conversions.DecimalConversion();
+            if (value instanceof ByteBuffer bytes) {
+                return conversion.fromBytes(bytes.duplicate(), schema, decimal);
+            }
+            if (value instanceof GenericFixed fixed) {
+                return conversion.fromFixed(fixed, schema, decimal);
+            }
+            if (value instanceof BigDecimal) {
+                return value;
+            }
+        }
+        if (!(value instanceof Number number)) {
+            return null;
+        }
+        return switch (logicalType) {
+            case "date" -> LocalDate.ofEpochDay(number.longValue()).toString();
+            case "time-millis" -> LocalTime.ofNanoOfDay(number.longValue() * 1_000_000L).toString();
+            case "time-micros" -> LocalTime.ofNanoOfDay(number.longValue() * 1_000L).toString();
+            case "timestamp-millis" -> Instant.ofEpochMilli(number.longValue()).toString();
+            case "timestamp-micros" -> instantFromMicros(number.longValue()).toString();
+            case "local-timestamp-millis" -> LocalDateTime.ofInstant(
+                    Instant.ofEpochMilli(number.longValue()), ZoneOffset.UTC).toString();
+            case "local-timestamp-micros" -> LocalDateTime.ofInstant(
+                    instantFromMicros(number.longValue()), ZoneOffset.UTC).toString();
+            default -> null;
+        };
+    }
+
+    private static Instant instantFromMicros(long micros) {
+        long seconds = Math.floorDiv(micros, 1_000_000L);
+        long nanos = Math.floorMod(micros, 1_000_000L) * 1_000L;
+        return Instant.ofEpochSecond(seconds, nanos);
+    }
+
+    private static Schema resolveUnion(Object value, Schema schema) {
+        if (schema == null || schema.getType() != Schema.Type.UNION || value == null) {
+            return schema;
+        }
+        try {
+            return schema.getTypes().get(GenericData.get().resolveUnion(schema, value));
+        } catch (RuntimeException ignored) {
+            return schema;
+        }
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/CsvTabularReader.java

@@ -0,0 +1,111 @@
+package io.mainframe.migration.validator;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+final class CsvTabularReader implements TabularReader {
+    private final CSVParser parser;
+    private final Iterator<CSVRecord> records;
+    private final List<String> columns;
+    private final boolean namedColumns;
+    private List<String> bufferedRow;
+
+    CsvTabularReader(InputOptions options) throws IOException {
+        namedColumns = options.header();
+        Reader reader = Files.newBufferedReader(options.path(), options.charset());
+        try {
+            CSVFormat format = CSVFormat.DEFAULT.builder()
+                    .setDelimiter(options.delimiter())
+                    .setIgnoreEmptyLines(false)
+                    .get();
+            parser = format.parse(reader);
+            records = parser.iterator();
+            List<String> first = nextRecord();
+            if (first == null) {
+                columns = List.of();
+            } else if (options.header()) {
+                columns = List.copyOf(stripBom(first));
+            } else {
+                bufferedRow = stripBom(first);
+                columns = generatedColumns(first.size());
+            }
+        } catch (Throwable throwable) {
+            try {
+                reader.close();
+            } catch (IOException closeError) {
+                throwable.addSuppressed(closeError);
+            }
+            throw throwable;
+        }
+    }
+
+    @Override
+    public List<String> columns() {
+        return columns;
+    }
+
+    @Override
+    public boolean hasNamedColumns() {
+        return namedColumns;
+    }
+
+    @Override
+    public List<String> readRow() throws IOException {
+        if (bufferedRow != null) {
+            List<String> row = bufferedRow;
+            bufferedRow = null;
+            return row;
+        }
+        return nextRecord();
+    }
+
+    private List<String> nextRecord() throws IOException {
+        try {
+            if (!records.hasNext()) {
+                return null;
+            }
+            CSVRecord record = records.next();
+            List<String> values = new ArrayList<>(record.size());
+            record.forEach(values::add);
+            return values;
+        } catch (UncheckedIOException exception) {
+            throw exception.getCause();
+        } catch (IllegalStateException exception) {
+            if (exception.getCause() instanceof IOException cause) {
+                throw cause;
+            }
+            throw exception;
+        }
+    }
+
+    private static List<String> generatedColumns(int size) {
+        List<String> names = new ArrayList<>(size);
+        for (int index = 1; index <= size; index++) {
+            names.add("COLUMN_" + index);
+        }
+        return List.copyOf(names);
+    }
+
+    private static List<String> stripBom(List<String> values) {
+        if (values.isEmpty() || values.get(0).isEmpty() || values.get(0).charAt(0) != '\uFEFF') {
+            return values;
+        }
+        List<String> result = new ArrayList<>(values);
+        result.set(0, result.get(0).substring(1));
+        return result;
+    }
+
+    @Override
+    public void close() throws IOException {
+        parser.close();
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/DataFormat.java

@@ -0,0 +1,62 @@
+package io.mainframe.migration.validator;
+
+import java.nio.file.Path;
+import java.nio.file.Files;
+import java.io.IOException;
+import java.util.Locale;
+import java.util.stream.Stream;
+
+public enum DataFormat {
+    AUTO,
+    CSV,
+    PARQUET;
+
+    public static DataFormat parse(String value) {
+        try {
+            return valueOf(value.trim().toUpperCase(Locale.ROOT));
+        } catch (RuntimeException exception) {
+            throw new IllegalArgumentException("Formato inválido: " + value + ". Use auto, csv ou parquet.");
+        }
+    }
+
+    public DataFormat resolve(Path path) {
+        if (this != AUTO) {
+            return this;
+        }
+        if (Files.isDirectory(path)) {
+            boolean csv = false;
+            boolean parquet = false;
+            try (Stream<Path> entries = Files.list(path)) {
+                for (Path entry : entries.toList()) {
+                    String name = entry.getFileName().toString().toLowerCase(Locale.ROOT);
+                    if (!Files.isRegularFile(entry) || !name.startsWith("part-")) {
+                        continue;
+                    }
+                    csv |= name.endsWith(".csv");
+                    parquet |= name.endsWith(".parquet") || name.endsWith(".parq");
+                }
+            } catch (IOException exception) {
+                throw new IllegalArgumentException("Não foi possível listar o diretório: " + path, exception);
+            }
+            if (csv && !parquet) {
+                return CSV;
+            }
+            if (parquet && !csv) {
+                return PARQUET;
+            }
+            if (csv && parquet) {
+                throw new IllegalArgumentException("Diretório contém partes CSV e Parquet: " + path);
+            }
+            throw new IllegalArgumentException("Nenhum part-*.csv ou part-*.parquet encontrado em: " + path);
+        }
+        String name = path.getFileName().toString().toLowerCase(Locale.ROOT);
+        if (name.endsWith(".csv")) {
+            return CSV;
+        }
+        if (name.endsWith(".parquet") || name.endsWith(".parq")) {
+            return PARQUET;
+        }
+        throw new IllegalArgumentException(
+                "Não foi possível inferir o formato de " + path + ". Informe --format ou o override por arquivo.");
+    }
+}

mainframe_toolkit/_workspace/validator-java/src/main/java/io/mainframe/migration/validator/Difference.java

@@ -0,0 +1,34 @@
+package io.mainframe.migration.validator;
+
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@JsonPropertyOrder({"line", "key", "columnIndex", "column", "expected", "actual", "reason"})
+public record Difference(
+        long line,
+        Map<String, String> key,
+        int columnIndex,
+        String column,
+        String expected,
+        String actual,
+        String reason) {
+
+    public Difference {
+        key = key == null || key.isEmpty()
+                ? Map.of()
+                : Collections.unmodifiableMap(new LinkedHashMap<>(key));
+    }
+
+    public Difference(
+            long line,
+            int columnIndex,
+            String column,
+            String expected,
+            String actual,
+            String reason) {
+        this(line, Map.of(), columnIndex, column, expected, actual, reason);
+    }
+}