From dbd098c24c8d3e1776e5043a472fa51ac97bcc4a Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Wed, 3 Jul 2024 13:30:42 +0530 Subject: [PATCH 1/9] Add initial gradle, ballerina and native files into the csv data module --- .gitignore | 24 +- README.md | 455 ++- ballerina/Ballerina.toml | 25 + ballerina/CompilerPlugin.toml | 6 + ballerina/Dependencies.toml | 28 + ballerina/Package.md | 400 +++ ballerina/build.gradle | 143 + ballerina/csv_api.bal | 52 + ballerina/init.bal | 25 + ballerina/tests/types.bal | 2634 +++++++++++++++++ ballerina/types.bal | 73 + build-config/checkstyle/build.gradle | 48 + build-config/resources/Ballerina.toml | 25 + build-config/resources/CompilerPlugin.toml | 6 + build.gradle | 96 + compiler-plugin-test/build.gradle | 108 + .../csvdata/compiler/CompilerPluginTest.java | 26 + .../src/test/resources/testng.xml | 27 + compiler-plugin/build.gradle | 74 + .../compiler/CsvDataCompilerPlugin.java | 35 + .../src/main/java/module-info.java | 23 + gradle.properties | 23 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 59536 bytes gradle/wrapper/gradle-wrapper.properties | 7 + gradlew | 248 ++ gradlew.bat | 92 + native/build.gradle | 80 + .../stdlib/data/csvdata/csv/Native.java | 78 + .../data/csvdata/utils/ModuleUtils.java | 46 + native/src/main/java/module-info.java | 21 + native/src/main/resources/error.properties | 100 + settings.gradle | 61 + 32 files changed, 5087 insertions(+), 2 deletions(-) create mode 100644 ballerina/Ballerina.toml create mode 100644 ballerina/CompilerPlugin.toml create mode 100644 ballerina/Dependencies.toml create mode 100644 ballerina/Package.md create mode 100644 ballerina/build.gradle create mode 100644 ballerina/csv_api.bal create mode 100644 ballerina/init.bal create mode 100644 ballerina/tests/types.bal create mode 100644 ballerina/types.bal create mode 100644 build-config/checkstyle/build.gradle create mode 100644 build-config/resources/Ballerina.toml create mode 100644 build-config/resources/CompilerPlugin.toml create mode 100644 build.gradle create mode 100644 compiler-plugin-test/build.gradle create mode 100644 compiler-plugin-test/src/test/java/io/ballerina/lib/data/csvdata/compiler/CompilerPluginTest.java create mode 100644 compiler-plugin-test/src/test/resources/testng.xml create mode 100644 compiler-plugin/build.gradle create mode 100644 compiler-plugin/src/main/java/io/ballerina/stdlib/data/csvdata/compiler/CsvDataCompilerPlugin.java create mode 100644 compiler-plugin/src/main/java/module-info.java create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100755 gradlew create mode 100644 gradlew.bat create mode 100644 native/build.gradle create mode 100644 native/src/main/java/io/ballerina/stdlib/data/csvdata/csv/Native.java create mode 100644 native/src/main/java/io/ballerina/stdlib/data/csvdata/utils/ModuleUtils.java create mode 100644 native/src/main/java/module-info.java create mode 100644 native/src/main/resources/error.properties create mode 100644 settings.gradle diff --git a/.gitignore b/.gitignore index 524f096..1d2a7ee 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,9 @@ # Log file *.log +# Lock file +*.lck + # BlueJ files *.ctxt @@ -12,6 +15,7 @@ # Package Files # *.jar +!gradle/wrapper/gradle-wrapper.jar *.war *.nar *.ear @@ -19,6 +23,24 @@ *.tar.gz *.rar -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.csv hs_err_pid* replay_pid* + +build +.gradle/ +target +bin/ + +# IDEA Files +.idea/ +*.iml +*.ipr +*.iws + +# MacOS +*.DS_Store + +# Ballerina +velocity.log* +*Ballerina.lock diff --git a/README.md b/README.md index 94f4ba4..ba9bc60 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,455 @@ -# module-ballerina-data.csv +# Ballerina CSV Data Library + The Ballerina CSV Data Library is a comprehensive toolkit designed to facilitate the handling and manipulation of CSV data within Ballerina applications. It streamlines the process of converting CSV data to native Ballerina data types, enabling developers to work with CSV content seamlessly and efficiently. + +This library is the refined successor of the `ballerina/csvdata` module, incorporating enhanced functionalities and improved performance. + +## Features + +- **Versatile CSV Data Input**: Accept CSV data as a csv, a string, byte array, or a stream and convert it into a Record value. +- **CSV to Record Value Conversion**: Transform CSV data into Ballerina records with ease in compliance with OpenAPI 3 standards. +- **Projection Support**: Perform selective conversion of CSV data subsets into Record values through projection. + +## Usage + +### Converting an CSV value to a Record value + +To convert an CSV value to a Record value, you can utilize the `fromCsvWithType` function provided by the library. The example below showcases the transformation of an CSV value into a Record value. + +```ballerina +import ballerina/data.csv; +import ballerina/io; + +public function main() returns error? { + csv data = csv ` + 0 + string + string + `; + + Book book = check csvdata:fromCsvWithType(data); + io:println(book); +} + +type Book record {| + int id; + string title; + string author; +|}; +``` + +### Converting an external CSV document to a Record value + +For transforming CSV content from an external source into a Record value, the `fromCsvStringWithType` function can be used. This external source can be in the form of a string or a byte array/byte stream that houses the CSV data. This is commonly extracted from files or network sockets. The example below demonstrates the conversion of an CSV value from an external source into a Record value. + +```ballerina +import ballerina/data.csv; +import ballerina/io; + +public function main() returns error? { + string csvContent = check io:fileReadString("path/to/file.csv"); + Book book = check csvdata:fromCsvStringWithType(csvContent); + io:println(book); +} + +type Book record {| + int id; + string title; + string author; +|}; +``` + +Make sure to handle possible errors that may arise during the file reading or CSV to record conversion process. The `check` keyword is utilized to handle these errors, but more sophisticated error handling can be implemented as per your requirements. + +## CSV to Record Canonical Representation + +The translation of CSV to a Record representation is a fundamental feature of the library. It facilitates a structured and type-safe approach to handling CSV data within Ballerina applications. + +Take for instance the following CSV snippet: + +```csv + + 0 + string + string + +``` + +CSV data is inherently hierarchical, forming a tree structure. In the given example, the root element is `book`, which encompasses three child elements: `id`, `title`, and `author`. The `id` element harbors a numeric value `0`, whereas both the `title` and `author` elements contain string values. + +A straightforward record representation of the above CSV data is: + +```ballerina +type Book record {| + int id; + string title; + string author; +|}; +``` + +In this representation, the CSV data is efficiently translated into a record value. The `book` element is mapped to a record of type `Book`, and the child elements `id`, `title`, and `author` are converted into record fields of types `int` and `string` correspondingly. + +This record type definition can be further refined through annotations. Moreover, utilizing open and closed records grants control over the translation process, which is elaborated in subsequent sections. + +### CSV Element Names + +The name of the CSV element serves as the name of the record field, altered to fit a valid Ballerina identifier. Notably, the record field name corresponds to the local name of the CSV element, with any namespace prefixes being disregarded. + +Consider the CSV snippet: + +```csv + + 0 + string + string + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record {| + int id; + string 'title\-name'; + string 'author\-name'; +|}; +``` + +Observe how the CSV element names `title-name` and `author-name` are represented using delimited identifiers in Ballerina; the `-` characters in the CSV element names are escaped using the `\` character. + +Moreover, the `@Name` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process: + +```ballerina +import ballerina/data.csv; + +type Book record {| + int id; + @csvdata:Name { value: "title-name" } + string title; + @csvdata:Name { value: "author-name" } + string author; +|}; +``` + +### CSV Attributes + +Similarly to CSV elements, CSV attributes are also represented into record fields within the corresponding parent Record type. The name of the CSV attribute is converted into the name of the record field, ensuring it is a valid Ballerina identifier. It is crucial to emphasize that the record field name aligns with the local name of the CSV attribute, and any namespace prefixes are ignored. + +Consider the following CSV snippet: + +```csv + + 0 + string + string + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record {| + string lang; + decimal price; + int id; + string title; + string author; +|}; +``` + +Additionally the `@Attribute` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process. + +### Child Elements + +Child elements are mapped to record fields, with the type reflecting that of the corresponding child element. + +Examine the CSV snippet below: + +```csv + + 0 + string + + string + string + + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record {| + int id; + string title; + Author author; +|}; + +type Author record {| + string name; + string country; +|}; +``` + +In this transformation, child elements, like the `author` element containing its own sub-elements, are converted into nested records. This maintains the hierarchical structure of the CSV data within the Ballerina type system, enabling intuitive and type-safe data manipulation. + +Alternatively, inline type definitions offer a compact method for representing child elements as records within their parent record. This approach is particularly beneficial when the child record does not require reuse elsewhere and is unique to its parent record. + +Consider the subsequent Ballerina record definition, which employs inline type definition for the `author` field: + +```ballerina +type Book record {| + int id; + string title; + record {| + string name; + string country; + |} author; +|}; +``` + +### CSV Text Content + +The transformation of CSV text content into record fields typically involves types like `string`, `boolean`, `int`, `float`, or `decimal`, depending on the textual content. For numeric values where type information is not explicitly defined, the default conversion type is `decimal`. Conversely, for non-numeric content, the default type is `string`. + +Consider the CSV snippet below: + +```csv + + 0 + string + string + true + 10.5 + +``` + +The translation into a Ballerina record would be as follows: + +```ballerina +type Book record {| + int id; + string title; + string author; + boolean available; + decimal price; +|}; +``` + +In scenarios where the parent CSV element of text content also includes attributes, the CSV text content can be represented by a `string` type field named `#content` within a record type, with the attributes being mapped to their respective fields. + +For instance, examine this CSV: + +```csv + + 0 + string + 10.5 + +``` + +The canonical translation of CSV to a Ballerina record is as such: + +```ballerina +type Book record {| + int id; + Title title; + decimal price; +|}; + +type Title record {| + string \#content; + string lang; +|}; +``` + +Modifications to the default behavior for converting numerical values can be achieved by providing `Options` mappings to the respective functions. This enables developers to choose specific data types and exert finer control over the conversion process. + +### CSV Namespaces + +CSV namespaces are accommodated by the library, supporting the translation of CSV data that contains namespace prefixes. However, the presence of CSV namespaces is not mandatory, and the library is capable of processing CSV data without namespaces. Should namespaces be present, they will be utilized to resolve the names of CSV elements and attributes. + +It's important to note that, unlike in the `csvdata` module, the namespace prefixes do not reflect in the record field names, as the record field names align with the local names of the CSV elements. + +Examine the CSV snippet below with default namespaces: + +```csv + + 0 + string + string + +``` + +The translation into a Ballerina record would be: + +```ballerina +type Book record {| + int id; + string title; + string author; +|}; +``` + +Incorporating namespace validation yields: + +```ballerina +import ballerina/data.csv; + +@csvdata:Namespace { + uri: "http://example.com/book" +} +type Book record {| + int id; + string title; + string author; +|}; +``` + +Here is the same CSV snippet with a namespace prefix: + +```csv + + 0 + string + string + +``` + +The translation into a Ballerina record would be: + +```ballerina +import ballerina/data.csv; + +@csvdata:Namespace { + uri: "http://example.com/book", + prefix: "bk" +} +type Book record {| + int id; + string title; + string author; +|}; +``` + +In these examples, the CSV namespaces are appropriately acknowledged, ensuring the integrity of the CSV structure within the Ballerina records. + +### Working with Arrays + +The library is equipped to handle the transformation of CSV data containing arrays into Ballerina records. + +Take the following CSV snippet as an example: + +```csv + + 0 + string + string + string + string + +``` + +The canonical representation of this CSV as a Ballerina record is: + +```ballerina +type Book record {| + int id; + string title; + string[] author; +|}; +``` + +### Controlling Which Elements to Convert + +The library allows for selective conversion of CSV elements into records through the use of rest fields. This is beneficial when the CSV data contains elements that are not necessary to be transformed into record fields. + +Take this CSV snippet as an example: + +```csv + + 0 + string + string + 10.5 + +``` + +Suppose that only the book `id`, and `title` elements are needed for conversion into record fields. This can be achieved by defining only the required fields in the record type and omitting the rest field: + +```ballerina +type Book record {| + int id; + string title; +|}; +``` + +However, if the rest field is utilized (or if the record type is defined as an open record), all elements in the CSV data will be transformed into record fields: + +```ballerina +type Book record {| + int id; + string title; +|}; +``` + +In this instance, all other elements in the CSV data, such as `author` and `price` along with their attributes, will be transformed into `string` type fields with the corresponding element name as the key. + +This behavior extends to arrays as well. + +The process of projecting CSV data into a record supports various use cases, including the filtering out of unnecessary elements. This functionality is anticipated to be enhanced in the future to accommodate more complex scenarios, such as filtering values based on regular expressions, among others. + +## Issues and projects + +Issues and Projects tabs are disabled for this repository as this is part of the Ballerina standard library. To report bugs, request new features, start new discussions, view project boards, etc. please visit Ballerina standard library [parent repository](https://github.com/ballerina-platform/ballerina-standard-library). + +This repository only contains the source code for the package. + +## Building from the source + +### Set up the prerequisites + +1. Download and install Java SE Development Kit (JDK) version 17 (from one of the following locations). + * [Oracle](https://www.oracle.com/java/technologies/downloads/) + * [OpenJDK](https://adoptium.net/) + +2. Export your GitHub personal access token with the read package permissions as follows. + + export packageUser= + export packagePAT= + +### Building the source + +Execute the commands below to build from source. + +1. To build the library: + + ./gradlew clean build + +2. Publish ZIP artifact to the local `.m2` repository: + + ./gradlew clean build publishToMavenLocal + +3. Publish the generated artifacts to the local Ballerina central repository: + + ./gradlew clean build -PpublishToLocalCentral=true + +4. Publish the generated artifacts to the Ballerina central repository: + + ./gradlew clean build -PpublishToCentral=true + +## Contributing to Ballerina + +As an open source project, Ballerina welcomes contributions from the community. + +For more information, go to the [contribution guidelines](https://github.com/ballerina-platform/ballerina-lang/blob/master/CONTRIBUTING.md). + +## Code of conduct + +All contributors are encouraged to read the [Ballerina code of conduct](https://ballerina.io/code-of-conduct). + +## Useful links + +[//]: # (* For more information go to the [`csvdata` library](https://lib.ballerina.io/ballerina/data.csv/latest).) +* Chat live with us via our [Discord server](https://discord.gg/ballerinalang). +* Post all technical questions on Stack Overflow with the [#ballerina](https://stackoverflow.com/questions/tagged/ballerina) tag. \ No newline at end of file diff --git a/ballerina/Ballerina.toml b/ballerina/Ballerina.toml new file mode 100644 index 0000000..f1d6945 --- /dev/null +++ b/ballerina/Ballerina.toml @@ -0,0 +1,25 @@ +[package] +org = "ballerina" +name = "data.csv" +version = "0.1.0" +authors = ["Ballerina"] +keywords = ["csv"] +repository = "https://github.com/ballerina-platform/module-ballerina-data.csv" +license = ["Apache-2.0"] +distribution = "2201.9.0" +export = ["data.csv"] + +[platform.java17] +graalvmCompatible = true + +[[platform.java17.dependency]] +groupId = "io.ballerina.stdlib" +artifactId = "data.csv-native" +version = "0.1.0" +path = "../native/build/libs/data.csv-native-0.1.0-SNAPSHOT.jar" + +[[platform.java17.dependency]] +groupId = "io.ballerina.stdlib" +artifactId = "constraint-native" +version = "1.5.0" +path = "./lib/constraint-native-1.5.0.jar" diff --git a/ballerina/CompilerPlugin.toml b/ballerina/CompilerPlugin.toml new file mode 100644 index 0000000..e503c45 --- /dev/null +++ b/ballerina/CompilerPlugin.toml @@ -0,0 +1,6 @@ +[plugin] +id = "constraint-compiler-plugin" +class = "io.ballerina.stdlib.data.csvdata.compiler.CsvDataCompilerPlugin" + +[[dependency]] +path = "../compiler-plugin/build/libs/data.csv-compiler-plugin-0.1.0-SNAPSHOT.jar" diff --git a/ballerina/Dependencies.toml b/ballerina/Dependencies.toml new file mode 100644 index 0000000..c07b540 --- /dev/null +++ b/ballerina/Dependencies.toml @@ -0,0 +1,28 @@ +# AUTO-GENERATED FILE. DO NOT MODIFY. + +# This file is auto-generated by Ballerina for managing dependency versions. +# It should not be modified by hand. + +[ballerina] +dependencies-toml-version = "2" +distribution-version = "2201.9.0" + +[[package]] +org = "ballerina" +name = "data.csv" +version = "0.1.0" +dependencies = [ + {org = "ballerina", name = "jballerina.java"} +] +modules = [ + {org = "ballerina", packageName = "data.csv", moduleName = "data.csv"} +] + +[[package]] +org = "ballerina" +name = "jballerina.java" +version = "0.0.0" +modules = [ + {org = "ballerina", packageName = "jballerina.java", moduleName = "jballerina.java"} +] + diff --git a/ballerina/Package.md b/ballerina/Package.md new file mode 100644 index 0000000..ea15954 --- /dev/null +++ b/ballerina/Package.md @@ -0,0 +1,400 @@ +# Package overview + +This package is designed to facilitate the handling and manipulation of CSV data within Ballerina applications. It streamlines the process of converting CSV data to native Ballerina data types, enabling developers to work with CSV content seamlessly and efficiently. + +This library is the refined successor of the `ballerina/csvdata` module, incorporating enhanced functionalities and improved performance. + +## Features + +- **Versatile CSV Data Input**: Accept CSV data as a csv, a string, byte array, or a stream and convert it into a Record value. +- **CSV to Record Value Conversion**: Transform CSV data into Ballerina records with ease in compliance with OpenAPI 3 standards. +- **Projection Support**: Perform selective conversion of CSV data subsets into Record values through projection. + +## Usage + +### Converting an CSV value to a Record value + +To convert an CSV value to a Record value, you can utilize the `fromCsvWithType` function provided by the library. The example below showcases the transformation of an CSV value into a Record value. + +```ballerina +import ballerina/data.csv as csvdata; +import ballerina/io; + +public function main() returns error? { + csv data = csv ` + 0 + string + string + `; + + Book book = check csvdata:fromCsvWithType(data, Book); + io:println(book); +} + +type Book record { + int id; + string title; + string author; +}; +``` + +### Converting an external CSV document to a Record value + +For transforming CSV content from an external source into a Record value, the `fromCsvStringWithType` function can be used. This external source can be in the form of a string or a byte array/byte stream that houses the CSV data. This is commonly extracted from files or network sockets. The example below demonstrates the conversion of an CSV value from an external source into a Record value. + +```ballerina +import ballerina/data.csv as csvdata; +import ballerina/io; + +public function main() returns error? { + string csvContent = check io:fileReadString("path/to/file.csv"); + Book book = check csvdata:fromCsvStringWithType(csvContent, Book); + io:println(book); +} + +type Book record { + int id; + string title; + string author; +}; +``` + +Make sure to handle possible errors that may arise during the file reading or CSV to record conversion process. The `check` keyword is utilized to handle these errors, but more sophisticated error handling can be implemented as per your requirements. + +## CSV to Record Canonical Representation + +The translation of CSV to a Record representation is a fundamental feature of the library. It facilitates a structured and type-safe approach to handling CSV data within Ballerina applications. + +Take for instance the following CSV snippet: + +```csv + + 0 + string + string + +``` + +CSV data is inherently hierarchical, forming a tree structure. In the given example, the root element is `book`, which encompasses three child elements: `id`, `title`, and `author`. The `id` element harbors a numeric value `0`, whereas both the `title` and `author` elements contain string values. + +A straightforward record representation of the above CSV data is: + +```ballerina +type Book record { + int id; + string title; + string author; +}; +``` + +In this representation, the CSV data is efficiently translated into a record value. The `book` element is mapped to a record of type `Book`, and the child elements `id`, `title`, and `author` are converted into record fields of types `int` and `string` correspondingly. + +This record type definition can be further refined through annotations. Moreover, utilizing open and closed records grants control over the translation process, which is elaborated in subsequent sections. + +### CSV Element Names + +The name of the CSV element serves as the name of the record field, altered to fit a valid Ballerina identifier. Notably, the record field name corresponds to the local name of the CSV element, with any namespace prefixes being disregarded. + +Consider the CSV snippet: + +```csv + + 0 + string + string + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record { + int id; + string 'title\-name'; + string 'author\-name'; +}; +``` + +Observe how the CSV element names `title-name` and `author-name` are represented using delimited identifiers in Ballerina; the `-` characters in the CSV element names are escaped using the `\` character. + +Moreover, the `@Name` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process: + +```ballerina +import ballerina/data.csv as csvdata; + +type Book record { + int id; + @csvdata:Name { value: "title-name" } + string title; + @csvdata:Name { value: "author-name" } + string author; +}; +``` + +### CSV Attributes + +Similarly to CSV elements, CSV attributes are also represented into record fields within the corresponding parent Record type. The name of the CSV attribute is converted into the name of the record field, ensuring it is a valid Ballerina identifier. It is crucial to emphasize that the record field name aligns with the local name of the CSV attribute, and any namespace prefixes are ignored. + +Consider the following CSV snippet: + +```csv + + 0 + string + string + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record { + string lang; + decimal price; + int id; + string title; + string author; +}; +``` + +Additionally the `@Attribute` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process. + +### Child Elements + +Child elements are mapped to record fields, with the type reflecting that of the corresponding child element. + +Examine the CSV snippet below: + +```csv + + 0 + string + + string + string + + +``` + +The canonical representation of the above CSV as a Ballerina record is: + +```ballerina +type Book record { + int id; + string title; + Author author; +}; + +type Author record { + string name; + string country; +}; +``` + +In this transformation, child elements, like the `author` element containing its own sub-elements, are converted into nested records. This maintains the hierarchical structure of the CSV data within the Ballerina type system, enabling intuitive and type-safe data manipulation. + +Alternatively, inline type definitions offer a compact method for representing child elements as records within their parent record. This approach is particularly beneficial when the child record does not require reuse elsewhere and is unique to its parent record. + +Consider the subsequent Ballerina record definition, which employs inline type definition for the `author` field: + +```ballerina +type Book record { + int id; + string title; + record { + string name; + string country; + } author; +}; +``` + +### CSV Text Content + +The transformation of CSV text content into record fields typically involves types like `string`, `boolean`, `int`, `float`, or `decimal`, depending on the textual content. For numeric values where type information is not explicitly defined, the default conversion type is `decimal`. Conversely, for non-numeric content, the default type is `string`. + +Consider the CSV snippet below: + +```csv + + 0 + string + string + true + 10.5 + +``` + +The translation into a Ballerina record would be as follows: + +```ballerina +type Book record { + int id; + string title; + string author; + boolean available; + decimal price; +}; +``` + +In scenarios where the parent CSV element of text content also includes attributes, the CSV text content can be represented by a `string` type field named `#content` within a record type, with the attributes being mapped to their respective fields. + +For instance, examine this CSV: + +```csv + + 0 + string + 10.5 + +``` + +The canonical translation of CSV to a Ballerina record is as such: + +```ballerina +type Book record { + int id; + Title title; + decimal price; +}; + +type Title record { + string \#content; + string lang; +}; +``` + +Modifications to the default behavior for converting numerical values can be achieved by providing `Options` mappings to the respective functions. This enables developers to choose specific data types and exert finer control over the conversion process. + +### CSV Namespaces + +CSV namespaces are accommodated by the library, supporting the translation of CSV data that contains namespace prefixes. However, the presence of CSV namespaces is not mandatory, and the library is capable of processing CSV data without namespaces. Should namespaces be present, they will be utilized to resolve the names of CSV elements and attributes. + +It's important to note that, unlike in the `csvdata` module, the namespace prefixes do not reflect in the record field names, as the record field names align with the local names of the CSV elements. + +Examine the CSV snippet below with default namespaces: + +```csv + + 0 + string + string + +``` + +The translation into a Ballerina record would be: + +```ballerina +type Book record { + int id; + string title; + string author; +}; +``` + +Incorporating namespace validation yields: + +```ballerina +import ballerina/data.csv as csvdata; + +@csvdata:Namespace { + uri: "http://example.com/book" +} +type Book record { + int id; + string title; + string author; +}; +``` + +Here is the same CSV snippet with a namespace prefix: + +```csv + + 0 + string + string + +``` + +The translation into a Ballerina record would be: + +```ballerina +import ballerina/data.csv as csvdata; + +@csvdata:Namespace { + uri: "http://example.com/book", + prefix: "bk" +} +type Book record { + int id; + string title; + string author; +}; +``` + +In these examples, the CSV namespaces are appropriately acknowledged, ensuring the integrity of the CSV structure within the Ballerina records. + +### Working with Arrays + +The library is equipped to handle the transformation of CSV data containing arrays into Ballerina records. + +Take the following CSV snippet as an example: + +```csv + + 0 + string + string + string + string + +``` + +The canonical representation of this CSV as a Ballerina record is: + +```ballerina +type Book record { + int id; + string title; + string[] author; +}; +``` + +### Controlling Which Elements to Convert + +The library allows for selective conversion of CSV elements into records through the use of rest fields. This is beneficial when the CSV data contains elements that are not necessary to be transformed into record fields. + +Take this CSV snippet as an example: + +```csv + + 0 + string + string + 10.5 + +``` + +Suppose that only the book `id`, and `title` elements are needed for conversion into record fields. This can be achieved by defining only the required fields in the record type and omitting the rest field: + +```ballerina +type Book record {| + int id; + string title; +|}; +``` + +However, if the rest field is utilized (or if the record type is defined as an open record), all elements in the CSV data will be transformed into record fields: + +```ballerina +type Book record { + int id; + string title; +}; +``` + +In this instance, all other elements in the CSV data, such as `author` and `price` along with their attributes, will be transformed into `string` type fields with the corresponding element name as the key. + +This behavior extends to arrays as well. + +The process of projecting CSV data into a record supports various use cases, including the filtering out of unnecessary elements. This functionality is anticipated to be enhanced in the future to accommodate more complex scenarios, such as filtering values based on regular expressions, among others. diff --git a/ballerina/build.gradle b/ballerina/build.gradle new file mode 100644 index 0000000..be27fbd --- /dev/null +++ b/ballerina/build.gradle @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +import org.apache.tools.ant.taskdefs.condition.Os + +buildscript { + repositories { + maven { + url = 'https://maven.pkg.github.com/ballerina-platform/plugin-gradle' + credentials { + username System.getenv("packageUser") + password System.getenv("packagePAT") + } + } + } + dependencies { + classpath "io.ballerina:plugin-gradle:${project.ballerinaGradlePluginVersion}" + } +} + +description = 'Ballerina - Data CSV Module' + +def packageName = "data.csv" +def packageOrg = "ballerina" + +def tomlVersion = stripBallerinaExtensionVersion("${project.version}") +def ballerinaTomlFilePlaceHolder = new File("${project.rootDir}/build-config/resources/Ballerina.toml") +def ballerinaTomlFile = new File("$project.projectDir/Ballerina.toml") + def compilerPluginTomlFilePlaceHolder = new File("${project.rootDir}/build-config/resources/CompilerPlugin.toml") + def compilerPluginTomlFile = new File("$project.projectDir/CompilerPlugin.toml") + +def stripBallerinaExtensionVersion(String extVersion) { + if (extVersion.matches(project.ext.timestampedVersionRegex)) { + def splitVersion = extVersion.split('-'); + if (splitVersion.length > 3) { + def strippedValues = splitVersion[0..-4] + return strippedValues.join('-') + } else { + return extVersion + } + } else { + return extVersion.replace("${project.ext.snapshotVersion}", "") + } +} + +apply plugin: 'io.ballerina.plugin' + +ballerina { + testCoverageParam = "--code-coverage --coverage-format=xml --includes=io.ballerina.stdlib.data.*:ballerina.*" + packageOrganization = packageOrg + module = packageName + langVersion = ballerinaLangVersion +} + +configurations { + externalJars +} + +dependencies { + externalJars(group: 'io.ballerina.stdlib', name: 'constraint-native', version: "${stdlibConstraintVersion}") { + transitive = false + } +} + +task updateTomlFiles { + doLast { + def stdlibDependentConstraintNativeVersion = stdlibConstraintVersion + def stdlibDependentConstraintVersion = stripBallerinaExtensionVersion("${stdlibDependentConstraintNativeVersion}") + def newConfig = ballerinaTomlFilePlaceHolder.text.replace("@project.version@", project.version) + newConfig = newConfig.replace("@toml.version@", tomlVersion) + newConfig = newConfig.replace("@stdlib.constraintnative.version@", stdlibDependentConstraintNativeVersion) + newConfig = newConfig.replace("@constraint.version@", stdlibDependentConstraintVersion) + ballerinaTomlFile.text = newConfig + + def newCompilerPluginToml = compilerPluginTomlFilePlaceHolder.text.replace("@project.version@", project.version) + compilerPluginTomlFile.text = newCompilerPluginToml + } +} + +task commitTomlFiles { + doLast { + project.exec { + ignoreExitValue true + if (Os.isFamily(Os.FAMILY_WINDOWS)) { + commandLine 'cmd', '/c', "git commit Ballerina.toml Dependencies.toml CompilerPlugin.toml -m '[Automated] Update the native jar versions'" + } else { + commandLine 'sh', '-c', "git commit Ballerina.toml Dependencies.toml CompilerPlugin.toml -m '[Automated] Update the native jar versions'" + } + } + } +} + +publishing { + publications { + maven(MavenPublication) { + artifact source: createArtifactZip, extension: 'zip' + } + } + + repositories { + maven { + name = "GitHubPackages" + url = uri("https://maven.pkg.github.com/ballerina-platform/module-${packageOrg}-${packageName}") + credentials { + username = System.getenv("publishUser") + password = System.getenv("publishPAT") + } + } + } +} + +task deleteDependencyTomlFiles { + if (project.hasProperty("deleteDependencies")) { + delete "${project.projectDir}/Dependencies.toml" + } +} + + +updateTomlFiles.dependsOn copyStdlibs + +build.dependsOn "generatePomFileForMavenPublication" +build.dependsOn ":${packageName}-native:build" +build.dependsOn deleteDependencyTomlFiles +build.dependsOn ":${packageName}-compiler-plugin:build" +build.dependsOn deleteDependencyTomlFiles + +test.dependsOn ":${packageName}-native:build" +test.dependsOn ":${packageName}-native:build" +test.dependsOn ":${packageName}-compiler-plugin:build" diff --git a/ballerina/csv_api.bal b/ballerina/csv_api.bal new file mode 100644 index 0000000..ed6af24 --- /dev/null +++ b/ballerina/csv_api.bal @@ -0,0 +1,52 @@ +// Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). +// +// WSO2 LLC. licenses this file to you under the Apache License, +// Version 2.0 (the "License"); you may not use this file except +// in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +import ballerina/jballerina.java; + +public isolated function parseStringToRecord(string s, parseToRecordOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseBytesToRecord(byte[] s, parseToRecordOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseStreamToRecord(stream s, + parseToRecordOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseStringToList(string s, ParseOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseBytesToList(byte[] s, ParseOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseStreamToList(stream s, + ParseOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseRecordAsRecordType(record{}[] s, + RecordAsRecordOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseRecordAsListType(record{}[] s, string[] headerNames, + Options options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseListAsRecordType(string[][] s, string[]? customHeaders = (), + ListAsRecordOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + +public isolated function parseListAsListType(string[][] s, ListAsListOption options = {}, typedesc t = <>) + returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; diff --git a/ballerina/init.bal b/ballerina/init.bal new file mode 100644 index 0000000..a0a98cb --- /dev/null +++ b/ballerina/init.bal @@ -0,0 +1,25 @@ +// Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). +// +// WSO2 LLC. licenses this file to you under the Apache License, +// Version 2.0 (the "License"); you may not use this file except +// in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +import ballerina/jballerina.java; + +isolated function init() { + setModule(); +} + +isolated function setModule() = @java:Method { + 'class: "io.ballerina.stdlib.data.csvdata.utils.ModuleUtils" +} external; diff --git a/ballerina/tests/types.bal b/ballerina/tests/types.bal new file mode 100644 index 0000000..6a304ae --- /dev/null +++ b/ballerina/tests/types.bal @@ -0,0 +1,2634 @@ +type BooleanRecord1 record { + boolean b1; + boolean|string b2; + boolean|string? b3; + boolean b4; +}; + +type BooleanRecord2 record {| + boolean b1; + boolean|string b2; + boolean|string? b3; + boolean b4; +|}; + +type BooleanRecord3 record {| + boolean b1; + boolean? b3; +|}; + +type BooleanRecord4 record { + boolean b1; + boolean? b3; +}; + +type BooleanRecord5 record { + boolean b1; + boolean? b3; + string defaultableField = ""; + string? nillableField = (); +}; + +type BooleanRecord6 record {| + boolean b1; + boolean? b3; + string defaultableField = ""; + string? nillableField = (); +|}; + +type BooleanRecord7 record { + boolean b1; + boolean? b3; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type BooleanRecord8 record {| + boolean b1; + boolean? b3; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type BooleanRecord9 record {| + boolean b1; + boolean? b3; + boolean?...; +|}; + +type BooleanRecord10 record {| + boolean...; +|}; + +type BooleanRecord11 record {| + boolean b1; + string defaultableField = ""; + string? nillableField = (); + boolean?|string...; +|}; + +type BooleanRecord12 record {| + boolean b1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + boolean...; +|}; + +type BooleanRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + string|boolean...; +|}; + +type BooleanRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + boolean...; +|}; + +type BooleanRecord15 record {| + int b1; + string defaultableField = ""; + string? nillableField = (); + boolean?...; +|}; + +type BooleanRecord16 record {| + boolean?...; +|}; + +type BooleanRecord17 record {| + int...; +|}; + +type BooleanRecord18 record {| + boolean b2; + int?...; +|}; + +type NilRecord1 record { + () n1; + () n2; + () n3; +}; + +type NilRecord2 record {| + () n1; + () n2; + () n3; +|}; + +type NilRecord3 record {| + () n1; + () n4; +|}; + +type NilRecord4 record { + () n1; + () n4; +}; + +type NilRecord5 record { + () n1; + () n4; + string defaultableField = ""; + string? nillableField = (); +}; + +type NilRecord6 record {| + () n1; + () n4; + string defaultableField = ""; + string? nillableField = (); +|}; + +type NilRecord7 record { + () n1; + () n4; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type NilRecord8 record {| + () n1; + () n4; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type NilRecord9 record {| + () n1; + () n2; + ()...; +|}; + +type NilRecord10 record {| + ()...; +|}; + +type NilRecord11 record {| + () n1; + string defaultableField = ""; + string? nillableField = (); + ()...; +|}; + +type NilRecord12 record {| + () n1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + ()...; +|}; + +type NilRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + ()...; +|}; + +type NilRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + ()...; +|}; + +type IntegerRecord1 record { + int i1; + int i2; + int i3; + int? i4; + int? i5; + int i6; + int i7; + int? i8; +}; + +type IntegerRecord2 record {| + int i1; + int? i2; + int i3; + int i4; + int? i5; + int i6; + int i7; + int? i8; +|}; + +type IntegerRecord3 record {| + int i1; + int i4; + int i6; +|}; + +type IntegerRecord4 record { + int i1; + int i4; + int i6; +}; + +type IntegerRecord5 record { + int i1; + int i4; + int i6; + string defaultableField = ""; + string? nillableField = (); +}; + +type IntegerRecord6 record {| + int i1; + int i4; + int i6; + string defaultableField = ""; + string? nillableField = (); +|}; + +type IntegerRecord7 record { + int i1; + int i4; + int i6; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type IntegerRecord8 record {| + int i1; + int i4; + int i6; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type IntegerRecord9 record {| + int i1; + int i2; + int...; +|}; + +type IntegerRecord10 record {| + int...; +|}; + +type IntegerRecord11 record {| + int i1; + string defaultableField = ""; + string? nillableField = (); + int...; +|}; + +type IntegerRecord12 record {| + int i1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + int...; +|}; + +type IntegerRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + int...; +|}; + +type IntegerRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + int...; +|}; + +type FloatRecord1 record { + float f1; + float f2; + float f3; + float f4; + float f5; + float f6; + float f7; + float f8; +}; + +type FloatRecord2 record {| + float f1; + float f2; + float f3; + float f4; + float f5; + float f6; + float f7; + float f8; +|}; + +type FloatRecord3 record {| + float f1; + float f4; + float f7; +|}; + +type FloatRecord4 record { + float f1; + float f4; + float f7; +}; + +type FloatRecord5 record { + float f1; + float f4; + float f7; + string defaultableField = ""; + string? nillableField = (); +}; + +type FloatRecord6 record {| + float f1; + float f4; + float f7; + string defaultableField = ""; + string? nillableField = (); +|}; + +type FloatRecord7 record { + float f1; + float f4; + float f7; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type FloatRecord8 record {| + float f1; + float f4; + float f7; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type FloatRecord9 record {| + float f1; + float f2; + float...; +|}; + +type FloatRecord10 record {| + float...; +|}; + +type FloatRecord11 record {| + float f1; + string defaultableField = ""; + string? nillableField = (); + float...; +|}; + +type FloatRecord12 record {| + float f1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + float...; +|}; + +type FloatRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + float...; +|}; + +type FloatRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + float...; +|}; + +type DecimalRecord1 record { + decimal d1; + decimal d2; + decimal d3; + decimal d4; + decimal d5; + decimal d6; + decimal d7; + decimal d8; +}; + +type DecimalRecord2 record {| + decimal d1; + decimal d2; + decimal d3; + decimal d4; + decimal d5; + decimal d6; + decimal d7; + decimal d8; +|}; + +type DecimalRecord3 record {| + decimal d1; + decimal d4; + decimal d7; +|}; + +type DecimalRecord4 record { + decimal d1; + decimal d4; + decimal d7; +}; + +type DecimalRecord5 record { + decimal d1; + decimal d4; + decimal d7; + string defaultableField = ""; + string? nillableField = (); +}; + +type DecimalRecord6 record {| + decimal d1; + decimal d4; + decimal d7; + string defaultableField = ""; + string? nillableField = (); +|}; + +type DecimalRecord7 record { + decimal d1; + decimal d4; + decimal d7; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type DecimalRecord8 record {| + decimal d1; + decimal d4; + decimal d7; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type DecimalRecord9 record {| + decimal d1; + decimal d2; + decimal...; +|}; + +type DecimalRecord10 record {| + decimal...; +|}; + +type DecimalRecord11 record {| + decimal d1; + string defaultableField = ""; + string? nillableField = (); + decimal...; +|}; + +type DecimalRecord12 record {| + decimal d1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + decimal...; +|}; + +type DecimalRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + decimal...; +|}; + +type DecimalRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + decimal...; +|}; + +type StringRecord1 record { + string s1; + string s2; + string s3; +}; + +type StringRecord2 record {| + string s1; + string s2; + string s3; +|}; + +type StringRecord3 record {| + string s1; + string s4; +|}; + +type StringRecord4 record { + string s1; + string s4; +}; + +type StringRecord5 record { + string s1; + string s4; + string defaultableField = ""; + string? nillableField = (); +}; + +type StringRecord6 record {| + string s1; + string s4; + string defaultableField = ""; + string? nillableField = (); +|}; + +type StringRecord7 record { + string s1; + string s4; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +}; + +type StringRecord8 record {| + string s1; + string s4; + string defaultableField = ""; + string? nillableField = (); + string requiredField; +|}; + +type StringRecord9 record {| + string s1; + string s2; + string...; +|}; + +type StringRecord10 record {| + string...; +|}; + +type StringRecord11 record {| + string s1; + string defaultableField = ""; + string? nillableField = (); + string...; +|}; + +type StringRecord12 record {| + string d1; + string defaultableField = ""; + string? nillableField = (); + string requiredField; + string...; +|}; + +type StringRecord13 record {| + string defaultableField = ""; + string? nillableField = (); + string...; +|}; + +type StringRecord14 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + string...; +|}; + +type StringRecord15 record {| + string defaultableField = ""; + string? nillableField = (); + string requiredField; + string...; +|}; + +type StringRecord16 record {| + string?...; +|}; + +type StringRecord17 record {| + int...; +|}; + +type StringRecord18 record {| + string b2; + int?...; +|}; + +type StringRecord19 record { + string s1 = ""; + string s2 = ""; +}; + +type StringRecord20 record {| + string s1 = ""; + string s2 = ""; +|}; + +type StringRecord21 record { +}; + +type StringRecord22 record {| + string s1 = ""; + string s2 = ""; + json...; +|}; + +type StringRecord23 record {| + json...; +|}; + +type JsonRecord1 record { + json j1; + json j2; + json j3; +}; + +type JsonRecord2 record {| + json j1; + json j2; + json j3; +|}; + +type JsonRecord3 record {| + json j1; + json j4; +|}; + +type JsonRecord4 record { + json j1; + json j4; +}; + +type JsonRecord5 record { + json j1; + json j4; + json defaultableField = ""; + json? nillableField = (); +}; + +type JsonRecord6 record {| + json j1; + json j4; + json defaultableField = ""; + json? nillableField = (); +|}; + +type JsonRecord7 record { + json j1; + json j4; + json defaultableField = ""; + json? nillableField = (); + json requiredField; +}; + +type JsonRecord8 record {| + json j1; + json j4; + json defaultableField = ""; + json? nillableField = (); + json requiredField; +|}; + +type JsonRecord9 record {| + json j1; + json j2; + json...; +|}; + +type JsonRecord10 record {| + json...; +|}; + +type JsonRecord11 record {| + json j1; + json defaultableField = ""; + json? nillableField = (); + json...; +|}; + +type JsonRecord12 record {| + json j1; + json defaultableField = ""; + json? nillableField = (); + json requiredField; + json...; +|}; + +type JsonRecord13 record {| + json defaultableField = ""; + json? nillableField = (); + json...; +|}; + +type JsonRecord14 record {| + json defaultableField = ""; + json? nillableField = (); + json requiredField; + json...; +|}; + +type AnydataRecord1 record { + anydata anydata1; + anydata anydata2; + anydata anydata3; +}; + +type AnydataRecord2 record {| + anydata anydata1; + anydata anydata2; + anydata anydata3; +|}; + +type AnydataRecord3 record {| + anydata anydata1; + anydata anydata4; +|}; + +type AnydataRecord4 record { + anydata anydata1; + anydata anydata4; +}; + +type AnydataRecord5 record { + anydata anydata1; + anydata anydata4; + anydata defaultableField = ""; + anydata? nillableField = (); +}; + +type AnydataRecord6 record {| + anydata anydata1; + anydata anydata4; + anydata defaultableField = ""; + anydata? nillableField = (); +|}; + +type AnydataRecord7 record { + anydata anydata1; + anydata anydata4; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; +}; + +type AnydataRecord8 record {| + anydata anydata1; + anydata anydata4; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; +|}; + +type AnydataRecord9 record {| + anydata anydata1; + anydata anydata2; + anydata...; +|}; + +type AnydataRecord10 record {| + anydata...; +|}; + +type AnydataRecord11 record {| + anydata anydata1; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata...; +|}; + +type AnydataRecord12 record {| + anydata anydata1; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; + anydata...; +|}; + +type AnydataRecord13 record {| + anydata defaultableField = ""; + anydata? nillableField = (); + anydata...; +|}; + +type AnydataRecord14 record {| + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; + anydata...; +|}; + +type CustomRecord1 record { + int i1; + int i2; + string s1; + string s2; + boolean b1; + boolean b2; + () n1; + () n2; + float f1; + float f2; + decimal d1; + decimal d2; +}; + +type CustomRecord2 record {| + int i1; + int i2; + string s1; + string s2; + boolean b1; + boolean b2; + () n1; + () n2; + float f1; + float f2; + decimal d1; + decimal d2; +|}; + +type CustomRecord3 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; +|}; + +type CustomRecord4 record { + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; +}; + +type CustomRecord5 record { + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + string defaultableField = ""; + string? nillableField = (); +}; + +type CustomRecord6 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata defaultableField = ""; + anydata? nillableField = (); +|}; + +type CustomRecord7 record { + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; +}; + +type CustomRecord8 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; +|}; + +type CustomRecord9 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + string...; +|}; + +type CustomRecord10 record {| + string...; +|}; + +type CustomRecord11 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata defaultableField = ""; + anydata? nillableField = (); + string...; +|}; + +type CustomRecord12 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; + string...; +|}; + +type CustomRecord13 record {| + anydata defaultableField = ""; + anydata? nillableField = (); + string...; +|}; + +type CustomRecord14 record {| + anydata defaultableField = ""; + anydata? nillableField = (); + anydata requiredField; + string...; +|}; + +type CustomRecord15 record {| + string '1; + string '2; +|}; + +type CustomRecord16 record {| + string '1; + string '2; + string '3; + string '4; +|}; + +type CustomRecord17 record { + string '1; + string '2; +}; + +type CustomRecord18 record { + string '1; + string '2; + string '3; + string '4; +}; + +type CustomRecord19 record { + string '1; + string '2; + string '3 = ""; + string '4 = ""; +}; + +type CustomRecord20 record { + string '1; +}; + +type CustomRecord21 record {| + string '1; + json...; +|}; + +type CustomRecord22 record {| + string '1; + string...; +|}; + +type CustomRecord23 record {| + string '1; + string a = ""; + string...; +|}; + +type CustomRecord24 record {| + string '1; + string '2 = ""; + string...; +|}; + +type CustomRecord25 record {| + int '1; + string...; +|}; + +type CustomRecord26 record {| + string '1; + int...; +|}; + +type CustomRecord27 record {| + int i1; + string s1; + boolean b1; + () n1; + float f1; + decimal d1; + anydata a1; + json j1; + anydata defaultableField = ""; + anydata? nillableField = (); + string...; +|}; + +type CustomRecord28 record { + string '1; +}; + +type CustomRecord29 record { + int '1; +}; + +type CustomRecord30 record {| + string '1; + string '2; + string '3; + string '4; + string '5; + string '6; +|}; + +type CustomRecord31 record {| + string '1; + string '6; +|}; + +type CustomRecord32 record {| + int '1; +|}; + +type CustomRecord33 record {| + string '1; + string '2; + string '3; + string '4; + string '5; + string '6; +|}; + +type CustomRecord34 record { + string '1; + string '6; + string '5 = ""; +}; + +type CustomRecord35 record { + string '1; + string '6; + string '9 = ""; +}; + +type CustomRecord36 record {| + string '1; + string '6; + string '9 = ""; +|}; + +type CustomRecord37 record {| + string '1; + string '6; + string '5 = ""; +|}; + +type CustomRecord38 record {| + string '1; + string '2; + string '3; + string '4; + string '5; + string '6; + string ...; +|}; + +type CustomRecord39 record {| + string '1; + string '2; + string '3; + string '4; + string '5; + string '6; + json ...; +|}; + +type CustomRecord40 record {| + string '5; + string '6; + json ...; +|}; + +type CustomRecord41 record {| + json ...; +|}; + +type CustomRecord42 record {| + int '1; + string '2; + boolean '3; + decimal '4; + float '5; + () '6; +|}; + +type CustomRecord43 record { + int '1; + string '2; + boolean '3; + decimal '4; + float '5; + () '6; +}; + +type CustomRecord44 record {| + int '1; + string '2; + boolean '3; + decimal '4; + float '5; + () '6; + string ...; +|}; + +type CustomRecord45 record {| + int H1; + string H2; + boolean H3; + decimal H4; + float H5; + () H6; +|}; + +type CustomRecord46 record { + int H1; + string H2; + boolean H3; + decimal H4; + float H5; + () H6; +}; + +type CustomRecord47 record {| + int H1; + string H2; + boolean H3; + decimal H4; + float H5; + () H6; + string ...; +|}; + +type CustomRecord48 record { + string H1; + string H2; + string H3; + string H4; + string H5; + string H6; +}; + +type CustomRecord49 record {| + string H1; + string H2; + string H3; + string H4; + string H5; + string H6; +|}; + +type CustomRecord50 record { + int H1; + float H4; +}; + +type CustomRecord51 record {| + int H1; + float H4; +|}; + +type CustomRecord52 record {| + string H1; + string H4; + string ...; +|}; + +type CustomRecord53 record {| + int H1; + float H4; + decimal ...; +|}; + +type CustomRecord54 record {| + string H1 = ""; + string H4; + string '1; +|}; + +type CustomRecord55 record {| + string H1 = ""; + string H4 = ""; + int '1 = 10; +|}; + +type CustomRecord56 record { + string H1 = ""; + string H4 = ""; + anydata '1 = 10; +}; + +type BooleanTuple1 [boolean, boolean, boolean, boolean]; + +type BooleanTuple2 [boolean, boolean]; + +type BooleanTuple3 [boolean, boolean...]; + +type BooleanTuple4 [boolean...]; + +type NillableBooleanTuple5 [boolean?, boolean?, boolean?, boolean?, boolean?]; + +type NillableBooleanTuple6 [boolean?, boolean?]; + +type NillableBooleanTuple7 [boolean?, boolean?, boolean?...]; + +type NillableBooleanTuple8 [boolean?...]; + +type NillableIntBooleanTuple9 [int|boolean?, int|boolean?...]; + +type NilTuple1 [(), (), ()]; + +type NilTuple2 [(), ()]; + +type NilTuple3 [(), ()...]; + +type NilTuple4 [()...]; + +type IntegerTuple1 [int, int, int, int, int, int]; + +type IntegerTuple2 [int, int]; + +type IntegerTuple3 [int, int...]; + +type IntegerTuple4 [int...]; + +type FloatTuple1 [float, float, float, float, float, float, float]; + +type FloatTuple2 [float, float]; + +type FloatTuple3 [float, float...]; + +type FloatTuple4 [float...]; + +type DecimalTuple1 [decimal, decimal, decimal, decimal]; + +type DecimalTuple2 [decimal, decimal]; + +type DecimalTuple3 [decimal, decimal...]; + +type DecimalTuple4 [decimal...]; + +type StringTuple1 [string, string, string, string]; + +type StringTuple2 [string, string]; + +type StringTuple3 [string, string...]; + +type StringTuple4 [string...]; + +type AnydataTuple1 [anydata, anydata, anydata, anydata, anydata, + anydata, anydata, anydata, anydata, anydata, anydata, anydata, + anydata, anydata, anydata, anydata, anydata, anydata, anydata, + anydata, anydata, anydata, anydata]; + +type AnydataTuple2 [anydata, anydata]; + +type AnydataTuple3 [anydata, anydata...]; + +type AnydataTuple4 [anydata...]; + +type JsonTuple1 [json, json, json, json, json, json, json, json, + json, json, json, json, json, json, json, json, json, json, + json, json, json, json, json]; + +type JsonTuple2 [json, json]; + +type JsonTuple3 [json, json...]; + +type JsonTuple4 [json...]; + +type CustomTuple1 [string, int, decimal, float, (), boolean, anydata, json, string, int, decimal, float, (), boolean, anydata, json]; + +type CustomTuple2 [string, int, decimal, float, (), boolean, anydata, json]; + +type CustomTuple3 [string, int, decimal, float, (), boolean, anydata, json, string...]; + +type CustomTuple4 [string...]; + +type CustomTuple5 [string, int, decimal, float, (), boolean, anydata, json, anydata...]; + +type CustomTuple6 [anydata...]; + +type CustomTuple7 [int, string, boolean, (), float, decimal, json, anydata, string...]; + +type CustomTuple8 [int, string, boolean, (), float, decimal, json, anydata, int...]; + +type IntegerArray1 int[]; + +type IntegerArray2 int[2]; + +type IntegerArray3 int[]; + +type IntegerArray4 int[2]; + +type IntegerArray5 int[3]; + +type IntegerArray6 int[4]; + +type StringArray string[]; + +type NillableStringArray string?[]; + +type NillableIntOrUnionStringArray (int|string?)[]; + +type StringArray1 string[]; + +type StringArray2 string[2]; + +type StringArray3 string[]; + +type StringArray4 string[2]; + +type StringArray5 string[3]; + +type StringArray6 string[4]; + +type FloatArray1 float[]; + +type FloatArray2 float[2]; + +type FloatArray3 float[]; + +type FloatArray4 float[2]; + +type FloatArray5 float[3]; + +type FloatArray6 float[4]; + +type DecimalArray1 decimal[]; + +type DecimalArray2 decimal[2]; + +type DecimalArray3 decimal[]; + +type DecimalArray4 decimal[2]; + +type DecimalArray5 decimal[3]; + +type DecimalArray6 decimal[4]; + +type BooleanArray boolean[]; + +type NillableBooleanArray boolean?[]; + +type NillableIntOrUnionBooleanArray (int|boolean?)[]; + +type BooleanArray2 boolean[2]; + +type BooleanArray3 boolean[3]; + +type BooleanArray4 boolean[]; + +type BooleanArray5 boolean[2]; + +type BooleanArray6 boolean[4]; + +type NilArray1 ()[]; + +type NilArray2 ()[2]; + +type NilArray3 ()[]; + +type NilArray4 ()[2]; + +type NilArray5 ()[3]; + +type NilArray6 ()[4]; + +type JsonArray1 json[]; + +type JsonArray2 json[2]; + +type JsonArray3 json[]; + +type JsonArray4 json[2]; + +type JsonArray5 json[3]; + +type JsonArray6 json[4]; + +type AnydataArray1 anydata[]; + +type AnydataArray2 anydata[2]; + +type AnydataArray3 anydata[]; + +type AnydataArray4 anydata[2]; + +type AnydataArray5 anydata[3]; + +type AnydataArray6 anydata[4]; + +type CustomArray1 CustomTuple2[]; + +type CustomArray2 CustomTuple2[2]; + +type CustomArray3 CustomTuple2[]; + +type CustomArray4 CustomTuple2[2]; + +type CustomArray5 CustomTuple2[3]; + +type CustomArray6 CustomTuple2[4]; + +type IntegerMap map; + +type StringMap map; + +type NillableIntUnionStringMap map; + +type IntUnionStringMap map; + +type DecimalMap map; + +type FloatMap map; + +type BooleanMap map; + +type NillableBooleanMap map; + +type NillableIntUnionBooleanMap map; + +type IntUnionBooleanMap map; + +type NilMap map<()>; + +type JsonMap map; + +type AnydataMap map; + +type CustomMap map; + +type BooleanRecord1Array BooleanRecord1[]; + +type ClosedBooleanRecord1Array BooleanRecord1[3]; + +type BooleanRecord2Array BooleanRecord2[]; + +type ClosedBooleanRecord2Array BooleanRecord2[3]; + +type BooleanRecord3Array BooleanRecord3[]; + +type ClosedBooleanRecord3Array BooleanRecord3[3]; + +type BooleanRecord4Array BooleanRecord4[]; + +type ClosedBooleanRecord4Array BooleanRecord4[3]; + +type BooleanRecord5Array BooleanRecord5[]; + +type ClosedBooleanRecord5Array BooleanRecord5[3]; + +type BooleanRecord6Array BooleanRecord6[]; + +type ClosedBooleanRecord6Array BooleanRecord6[3]; + +type BooleanRecord7Array BooleanRecord7[]; + +type ClosedBooleanRecord7Array BooleanRecord7[3]; + +type BooleanRecord8Array BooleanRecord8[]; + +type ClosedBooleanRecord8Array BooleanRecord8[3]; + +type BooleanRecord9Array BooleanRecord9[]; + +type ClosedBooleanRecord9Array BooleanRecord9[3]; + +type BooleanRecord10Array BooleanRecord10[]; + +type ClosedBooleanRecord10Array BooleanRecord10[3]; + +type BooleanRecord11Array BooleanRecord11[]; + +type ClosedBooleanRecord11Array BooleanRecord11[3]; + +type BooleanRecord12Array BooleanRecord12[]; + +type ClosedBooleanRecord12Array BooleanRecord12[3]; + +type BooleanRecord13Array BooleanRecord13[]; + +type ClosedBooleanRecord13Array BooleanRecord13[3]; + +type BooleanRecord14Array BooleanRecord14[]; + +type ClosedBooleanRecord14Array BooleanRecord14[3]; + +type BooleanRecord15Array BooleanRecord15[]; + +type ClosedBooleanRecord15Array BooleanRecord15[3]; + +type BooleanRecord16Array BooleanRecord16[]; + +type ClosedBooleanRecord16Array BooleanRecord16[3]; + +type BooleanRecord17Array BooleanRecord17[]; + +type ClosedBooleanRecord17Array BooleanRecord17[3]; + +type BooleanRecord18Array BooleanRecord18[]; + +type ClosedBooleanRecord18Array BooleanRecord18[3]; + +type NilRecord1Array NilRecord1[]; + +type ClosedNilRecord1Array NilRecord1[3]; + +type NilRecord2Array NilRecord2[]; + +type ClosedNilRecord2Array NilRecord2[3]; + +type NilRecord3Array NilRecord3[]; + +type ClosedNilRecord3Array NilRecord3[3]; + +type NilRecord4Array NilRecord4[]; + +type ClosedNilRecord4Array NilRecord4[3]; + +type NilRecord5Array NilRecord5[]; + +type ClosedNilRecord5Array NilRecord5[3]; + +type NilRecord6Array NilRecord6[]; + +type ClosedNilRecord6Array NilRecord6[3]; + +type NilRecord7Array NilRecord7[]; + +type ClosedNilRecord7Array NilRecord7[3]; + +type NilRecord8Array NilRecord8[]; + +type ClosedNilRecord8Array NilRecord8[3]; + +type NilRecord9Array NilRecord9[]; + +type ClosedNilRecord9Array NilRecord9[3]; + +type NilRecord10Array NilRecord10[]; + +type ClosedNilRecord10Array NilRecord10[3]; + +type NilRecord11Array NilRecord11[]; + +type ClosedNilRecord11Array NilRecord11[3]; + +type NilRecord12Array NilRecord12[]; + +type ClosedNilRecord12Array NilRecord12[3]; + +type NilRecord13Array NilRecord13[]; + +type ClosedNilRecord13Array NilRecord13[3]; + +type NilRecord14Array NilRecord14[]; + +type ClosedNilRecord14Array NilRecord14[3]; + +type IntegerRecord1Array IntegerRecord1[]; + +type ClosedIntegerRecord1Array IntegerRecord1[3]; + +type IntegerRecord2Array IntegerRecord2[]; + +type ClosedIntegerRecord2Array IntegerRecord2[3]; + +type IntegerRecord3Array IntegerRecord3[]; + +type ClosedIntegerRecord3Array IntegerRecord3[3]; + +type IntegerRecord4Array IntegerRecord4[]; + +type ClosedIntegerRecord4Array IntegerRecord4[3]; + +type IntegerRecord5Array IntegerRecord5[]; + +type ClosedIntegerRecord5Array IntegerRecord5[3]; + +type IntegerRecord6Array IntegerRecord6[]; + +type ClosedIntegerRecord6Array IntegerRecord6[3]; + +type IntegerRecord7Array IntegerRecord7[]; + +type ClosedIntegerRecord7Array IntegerRecord7[3]; + +type IntegerRecord8Array IntegerRecord8[]; + +type ClosedIntegerRecord8Array IntegerRecord8[3]; + +type IntegerRecord9Array IntegerRecord9[]; + +type ClosedIntegerRecord9Array IntegerRecord9[3]; + +type IntegerRecord10Array IntegerRecord10[]; + +type ClosedIntegerRecord10Array IntegerRecord10[3]; + +type IntegerRecord11Array IntegerRecord11[]; + +type ClosedIntegerRecord11Array IntegerRecord11[3]; + +type IntegerRecord12Array IntegerRecord12[]; + +type ClosedIntegerRecord12Array IntegerRecord12[3]; + +type IntegerRecord13Array IntegerRecord13[]; + +type ClosedIntegerRecord13Array IntegerRecord13[3]; + +type IntegerRecord14Array IntegerRecord14[]; + +type ClosedIntegerRecord14Array IntegerRecord14[3]; + +type FloatRecord1Array FloatRecord1[]; + +type ClosedFloatRecord1Array FloatRecord1[3]; + +type FloatRecord2Array FloatRecord2[]; + +type ClosedFloatRecord2Array FloatRecord2[3]; + +type FloatRecord3Array FloatRecord3[]; + +type ClosedFloatRecord3Array FloatRecord3[3]; + +type FloatRecord4Array FloatRecord4[]; + +type ClosedFloatRecord4Array FloatRecord4[3]; + +type FloatRecord5Array FloatRecord5[]; + +type ClosedFloatRecord5Array FloatRecord5[3]; + +type FloatRecord6Array FloatRecord6[]; + +type ClosedFloatRecord6Array FloatRecord6[3]; + +type FloatRecord7Array FloatRecord7[]; + +type ClosedFloatRecord7Array FloatRecord7[3]; + +type FloatRecord8Array FloatRecord8[]; + +type ClosedFloatRecord8Array FloatRecord8[3]; + +type FloatRecord9Array FloatRecord9[]; + +type ClosedFloatRecord9Array FloatRecord9[3]; + +type FloatRecord10Array FloatRecord10[]; + +type ClosedFloatRecord10Array FloatRecord10[3]; + +type FloatRecord11Array FloatRecord11[]; + +type ClosedFloatRecord11Array FloatRecord11[3]; + +type FloatRecord12Array FloatRecord12[]; + +type ClosedFloatRecord12Array FloatRecord12[3]; + +type FloatRecord13Array FloatRecord13[]; + +type ClosedFloatRecord13Array FloatRecord13[3]; + +type FloatRecord14Array FloatRecord14[]; + +type ClosedFloatRecord14Array FloatRecord14[3]; + +type DecimalRecord1Array DecimalRecord1[]; + +type ClosedDecimalRecord1Array DecimalRecord1[3]; + +type DecimalRecord2Array DecimalRecord2[]; + +type ClosedDecimalRecord2Array DecimalRecord2[3]; + +type DecimalRecord3Array DecimalRecord3[]; + +type ClosedDecimalRecord3Array DecimalRecord3[3]; + +type DecimalRecord4Array DecimalRecord4[]; + +type ClosedDecimalRecord4Array DecimalRecord4[3]; + +type DecimalRecord5Array DecimalRecord5[]; + +type ClosedDecimalRecord5Array DecimalRecord5[3]; + +type DecimalRecord6Array DecimalRecord6[]; + +type ClosedDecimalRecord6Array DecimalRecord6[3]; + +type DecimalRecord7Array DecimalRecord7[]; + +type ClosedDecimalRecord7Array DecimalRecord7[3]; + +type DecimalRecord8Array DecimalRecord8[]; + +type ClosedDecimalRecord8Array DecimalRecord8[3]; + +type DecimalRecord9Array DecimalRecord9[]; + +type ClosedDecimalRecord9Array DecimalRecord9[3]; + +type DecimalRecord10Array DecimalRecord10[]; + +type ClosedDecimalRecord10Array DecimalRecord10[3]; + +type DecimalRecord11Array DecimalRecord11[]; + +type ClosedDecimalRecord11Array DecimalRecord11[3]; + +type DecimalRecord12Array DecimalRecord12[]; + +type ClosedDecimalRecord12Array DecimalRecord12[3]; + +type DecimalRecord13Array DecimalRecord13[]; + +type ClosedDecimalRecord13Array DecimalRecord13[3]; + +type DecimalRecord14Array DecimalRecord14[]; + +type ClosedDecimalRecord14Array DecimalRecord14[3]; + +type StringRecord1Array StringRecord1[]; + +type ClosedStringRecord1Array StringRecord1[3]; + +type StringRecord2Array StringRecord2[]; + +type ClosedStringRecord2Array StringRecord2[3]; + +type StringRecord3Array StringRecord3[]; + +type ClosedStringRecord3Array StringRecord3[3]; + +type StringRecord4Array StringRecord4[]; + +type ClosedStringRecord4Array StringRecord4[3]; + +type StringRecord5Array StringRecord5[]; + +type ClosedStringRecord5Array StringRecord5[3]; + +type StringRecord6Array StringRecord6[]; + +type ClosedStringRecord6Array StringRecord6[3]; + +type StringRecord7Array StringRecord7[]; + +type ClosedStringRecord7Array StringRecord7[3]; + +type StringRecord8Array StringRecord8[]; + +type ClosedStringRecord8Array StringRecord8[3]; + +type StringRecord9Array StringRecord9[]; + +type ClosedStringRecord9Array StringRecord9[3]; + +type StringRecord10Array StringRecord10[]; + +type ClosedStringRecord10Array StringRecord10[3]; + +type StringRecord11Array StringRecord11[]; + +type ClosedStringRecord11Array StringRecord11[3]; + +type StringRecord12Array StringRecord12[]; + +type ClosedStringRecord12Array StringRecord12[3]; + +type StringRecord13Array StringRecord13[]; + +type ClosedStringRecord13Array StringRecord13[3]; + +type StringRecord14Array StringRecord14[]; + +type ClosedStringRecord14Array StringRecord14[3]; + +type StringRecord15Array StringRecord15[]; + +type StringRecord16Array StringRecord16[]; + +type StringRecord17Array StringRecord17[]; + +type StringRecord18Array StringRecord18[]; + +type StringRecord19Array StringRecord19[]; + +type StringRecord20Array StringRecord20[]; + +type StringRecord21Array StringRecord21[]; + +type StringRecord22Array StringRecord22[]; + +type StringRecord23Array StringRecord23[]; + +type JsonRecord1Array JsonRecord1[]; + +type ClosedJsonRecord1Array JsonRecord1[3]; + +type JsonRecord2Array JsonRecord2[]; + +type ClosedJsonRecord2Array JsonRecord2[3]; + +type JsonRecord3Array JsonRecord3[]; + +type ClosedJsonRecord3Array JsonRecord3[3]; + +type JsonRecord4Array JsonRecord4[]; + +type ClosedJsonRecord4Array JsonRecord4[3]; + +type JsonRecord5Array JsonRecord5[]; + +type ClosedJsonRecord5Array JsonRecord5[3]; + +type JsonRecord6Array JsonRecord6[]; + +type ClosedJsonRecord6Array JsonRecord6[3]; + +type JsonRecord7Array JsonRecord7[]; + +type ClosedJsonRecord7Array JsonRecord7[3]; + +type JsonRecord8Array JsonRecord8[]; + +type ClosedJsonRecord8Array JsonRecord8[3]; + +type JsonRecord9Array JsonRecord9[]; + +type ClosedJsonRecord9Array JsonRecord9[3]; + +type JsonRecord10Array JsonRecord10[]; + +type ClosedJsonRecord10Array JsonRecord10[3]; + +type JsonRecord11Array JsonRecord11[]; + +type ClosedJsonRecord11Array JsonRecord11[3]; + +type JsonRecord12Array JsonRecord12[]; + +type ClosedJsonRecord12Array JsonRecord12[3]; + +type JsonRecord13Array JsonRecord13[]; + +type ClosedJsonRecord13Array JsonRecord13[3]; + +type JsonRecord14Array JsonRecord14[]; + +type ClosedJsonRecord14Array JsonRecord14[3]; + +type AnydataRecord1Array AnydataRecord1[]; + +type ClosedAnydataRecord1Array AnydataRecord1[3]; + +type AnydataRecord2Array AnydataRecord2[]; + +type ClosedAnydataRecord2Array AnydataRecord2[3]; + +type AnydataRecord3Array AnydataRecord3[]; + +type ClosedAnydataRecord3Array AnydataRecord3[3]; + +type AnydataRecord4Array AnydataRecord4[]; + +type ClosedAnydataRecord4Array AnydataRecord4[3]; + +type AnydataRecord5Array AnydataRecord5[]; + +type ClosedAnydataRecord5Array AnydataRecord5[3]; + +type AnydataRecord6Array AnydataRecord6[]; + +type ClosedAnydataRecord6Array AnydataRecord6[3]; + +type AnydataRecord7Array AnydataRecord7[]; + +type ClosedAnydataRecord7Array AnydataRecord7[3]; + +type AnydataRecord8Array AnydataRecord8[]; + +type ClosedAnydataRecord8Array AnydataRecord8[3]; + +type AnydataRecord9Array AnydataRecord9[]; + +type ClosedAnydataRecord9Array AnydataRecord9[3]; + +type AnydataRecord10Array AnydataRecord10[]; + +type ClosedAnydataRecord10Array AnydataRecord10[3]; + +type AnydataRecord11Array AnydataRecord11[]; + +type ClosedAnydataRecord11Array AnydataRecord11[3]; + +type AnydataRecord12Array AnydataRecord12[]; + +type ClosedAnydataRecord12Array AnydataRecord12[3]; + +type AnydataRecord13Array AnydataRecord13[]; + +type ClosedAnydataRecord13Array AnydataRecord13[3]; + +type AnydataRecord14Array AnydataRecord14[]; + +type ClosedAnydataRecord14Array AnydataRecord14[3]; + +type CustomRecord1Array CustomRecord1[]; + +type ClosedCustomRecord1Array CustomRecord1[3]; + +type CustomRecord2Array CustomRecord2[]; + +type ClosedCustomRecord2Array CustomRecord2[3]; + +type CustomRecord3Array CustomRecord3[]; + +type ClosedCustomRecord3Array CustomRecord3[3]; + +type CustomRecord4Array CustomRecord4[]; + +type ClosedCustomRecord4Array CustomRecord4[3]; + +type CustomRecord5Array CustomRecord5[]; + +type ClosedCustomRecord5Array CustomRecord5[3]; + +type CustomRecord6Array CustomRecord6[]; + +type ClosedCustomRecord6Array CustomRecord6[3]; + +type CustomRecord7Array CustomRecord7[]; + +type ClosedCustomRecord7Array CustomRecord7[3]; + +type CustomRecord8Array CustomRecord8[]; + +type ClosedCustomRecord8Array CustomRecord8[3]; + +type CustomRecord9Array CustomRecord9[]; + +type ClosedCustomRecord9Array CustomRecord9[3]; + +type CustomRecord10Array CustomRecord10[]; + +type ClosedCustomRecord10Array CustomRecord10[3]; + +type CustomRecord11Array CustomRecord11[]; + +type ClosedCustomRecord11Array CustomRecord11[3]; + +type CustomRecord12Array CustomRecord12[]; + +type ClosedCustomRecord12Array CustomRecord12[3]; + +type CustomRecord13Array CustomRecord13[]; + +type ClosedCustomRecord13Array CustomRecord13[3]; + +type CustomRecord14Array CustomRecord14[]; + +type ClosedCustomRecord14Array CustomRecord14[3]; + +type CustomRecord15Array CustomRecord15[]; + +type CustomRecord16Array CustomRecord16[]; + +type CustomRecord17Array CustomRecord17[]; + +type CustomRecord18Array CustomRecord18[]; + +type CustomRecord19Array CustomRecord19[]; + +type CustomRecord20Array CustomRecord20[]; + +type CustomRecord21Array CustomRecord21[]; + +type CustomRecord22Array CustomRecord22[]; + +type CustomRecord23Array CustomRecord23[]; + +type CustomRecord24Array CustomRecord24[]; + +type CustomRecord25Array CustomRecord25[]; + +type CustomRecord26Array CustomRecord26[]; + +type CustomRecord27Array CustomRecord27[]; +type CustomRecord28Array CustomRecord28[]; +type CustomRecord29Array CustomRecord29[]; +type CustomRecord30Array CustomRecord30[]; +type CustomRecord31Array CustomRecord31[]; +type CustomRecord32Array CustomRecord32[]; +type CustomRecord33Array CustomRecord33[]; +type CustomRecord34Array CustomRecord34[]; +type CustomRecord35Array CustomRecord35[]; +type CustomRecord36Array CustomRecord36[]; +type CustomRecord37Array CustomRecord37[]; +type CustomRecord38Array CustomRecord38[]; +type CustomRecord39Array CustomRecord39[]; +type CustomRecord40Array CustomRecord40[]; +type CustomRecord41Array CustomRecord41[]; +type CustomRecord42Array CustomRecord42[]; +type CustomRecord43Array CustomRecord43[]; +type CustomRecord44Array CustomRecord44[]; +type CustomRecord45Array CustomRecord45[]; +type CustomRecord46Array CustomRecord46[]; +type CustomRecord47Array CustomRecord47[]; +type CustomRecord48Array CustomRecord48[]; +type CustomRecord49Array CustomRecord49[]; +type CustomRecord50Array CustomRecord50[]; +type CustomRecord51Array CustomRecord51[]; +type CustomRecord52Array CustomRecord52[]; +type CustomRecord53Array CustomRecord53[]; +type CustomRecord54Array CustomRecord54[]; +type CustomRecord55Array CustomRecord55[]; +type CustomRecord56Array CustomRecord56[]; +// type CustomRecord57Array CustomRecord57[]; + +type BooleanTuple1Array BooleanTuple1[]; + +type ClosedBooleanTuple1Array BooleanTuple1[3]; + +type BooleanTuple2Array BooleanTuple2[]; + +type ClosedBooleanTuple2Array BooleanTuple2[3]; + +type BooleanTuple3Array BooleanTuple3[]; + +type ClosedBooleanTuple3Array BooleanTuple3[3]; + +type BooleanTuple4Array BooleanTuple4[]; + +type ClosedBooleanTuple4Array BooleanTuple4[3]; + +type NillableBooleanTuple5Array NillableBooleanTuple5[]; + +type NillableBooleanTuple6Array NillableBooleanTuple6[]; + +type NillableBooleanTuple7Array NillableBooleanTuple7[]; + +type NillableBooleanTuple8Array NillableBooleanTuple8[]; + +type NillableIntBooleanTuple9Array NillableIntBooleanTuple9[]; + +type NilTuple1Array NilTuple1[]; + +type ClosedNilTuple1Array NilTuple1[3]; + +type NilTuple2Array NilTuple2[]; + +type ClosedNilTuple2Array NilTuple2[3]; + +type NilTuple3Array NilTuple3[]; + +type ClosedNilTuple3Array NilTuple3[3]; + +type NilTuple4Array NilTuple4[]; + +type ClosedNilTuple4Array NilTuple4[3]; + +type IntegerTuple1Array IntegerTuple1[]; + +type ClosedIntegerTuple1Array IntegerTuple1[3]; + +type IntegerTuple2Array IntegerTuple2[]; + +type ClosedIntegerTuple2Array IntegerTuple2[3]; + +type IntegerTuple3Array IntegerTuple3[]; + +type ClosedIntegerTuple3Array IntegerTuple3[3]; + +type IntegerTuple4Array IntegerTuple4[]; + +type ClosedIntegerTuple4Array IntegerTuple4[3]; + +type FloatTuple1Array FloatTuple1[]; + +type ClosedFloatTuple1Array FloatTuple1[3]; + +type FloatTuple2Array FloatTuple2[]; + +type ClosedFloatTuple2Array FloatTuple2[3]; + +type FloatTuple3Array FloatTuple3[]; + +type ClosedFloatTuple3Array FloatTuple3[3]; + +type FloatTuple4Array FloatTuple4[]; + +type ClosedFloatTuple4Array FloatTuple4[3]; + +type DecimalTuple1Array DecimalTuple1[]; + +type ClosedDecimalTuple1Array DecimalTuple1[3]; + +type DecimalTuple2Array DecimalTuple2[]; + +type ClosedDecimalTuple2Array DecimalTuple2[3]; + +type DecimalTuple3Array DecimalTuple3[]; + +type ClosedDecimalTuple3Array DecimalTuple3[3]; + +type DecimalTuple4Array DecimalTuple4[]; + +type ClosedDecimalTuple4Array DecimalTuple4[3]; + +type StringTuple1Array StringTuple1[]; + +type ClosedStringTuple1Array StringTuple1[3]; + +type StringTuple2Array StringTuple2[]; + +type ClosedStringTuple2Array StringTuple2[3]; + +type StringTuple3Array StringTuple3[]; + +type ClosedStringTuple3Array StringTuple3[3]; + +type StringTuple4Array StringTuple4[]; + +type ClosedStringTuple4Array StringTuple4[3]; + +type AnydataTuple1Array AnydataTuple1[]; + +type ClosedAnydataTuple1Array AnydataTuple1[3]; + +type AnydataTuple2Array AnydataTuple2[]; + +type ClosedAnydataTuple2Array AnydataTuple2[3]; + +type AnydataTuple3Array AnydataTuple3[]; + +type ClosedAnydataTuple3Array AnydataTuple3[3]; + +type AnydataTuple4Array AnydataTuple4[]; + +type ClosedAnydataTuple4Array AnydataTuple4[3]; + +type JsonTuple1Array JsonTuple1[]; + +type ClosedJsonTuple1Array JsonTuple1[3]; + +type JsonTuple2Array JsonTuple2[]; + +type ClosedJsonTuple2Array JsonTuple2[3]; + +type JsonTuple3Array JsonTuple3[]; + +type ClosedJsonTuple3Array JsonTuple3[3]; + +type JsonTuple4Array JsonTuple4[]; + +type ClosedJsonTuple4Array JsonTuple4[3]; + +type CustomTuple1Array CustomTuple1[]; + +type ClosedCustomTuple1Array CustomTuple1[3]; + +type CustomTuple2Array CustomTuple2[]; + +type ClosedCustomTuple2Array CustomTuple2[3]; + +type CustomTuple3Array CustomTuple3[]; + +type ClosedCustomTuple3Array CustomTuple3[3]; + +type CustomTuple4Array CustomTuple4[]; + +type ClosedCustomTuple4Array CustomTuple4[3]; + +type CustomTuple5Array CustomTuple5[]; + +type ClosedCustomTuple5Array CustomTuple5[3]; + +type CustomTuple6Array CustomTuple6[]; + +type CustomTuple7Array CustomTuple7[]; + +type CustomTuple8Array CustomTuple8[]; + +type ClosedCustomTuple6Array CustomTuple6[3]; + +type IntegerArray1Array IntegerArray1[]; + +type ClosedIntegerArray1Array IntegerArray1[3]; + +type IntegerArray2Array IntegerArray2[]; + +type ClosedIntegerArray2Array IntegerArray2[3]; + +type IntegerArray3Array IntegerArray3[]; + +type ClosedIntegerArray3Array IntegerArray3[3]; + +type IntegerArray4Array IntegerArray4[]; + +type ClosedIntegerArray4Array IntegerArray4[3]; + +type IntegerArray5Array IntegerArray5[]; + +type ClosedIntegerArray5Array IntegerArray5[3]; + +type IntegerArray6Array IntegerArray5[]; + +type ClosedIntegerArray6Array IntegerArray5[3]; + +type StringArray1Array StringArray1[]; + +type StringArrayArray StringArray[]; + +type NillableStringArrayArray NillableStringArray[]; + +type NillableIntOrUnionStringArrayArray NillableIntOrUnionStringArray[]; + +type ClosedStringArray1Array StringArray1[3]; + +type StringArray2Array StringArray2[]; + +type ClosedStringArray2Array StringArray2[3]; + +type StringArray3Array StringArray3[]; + +type ClosedStringArray3Array StringArray3[3]; + +type StringArray4Array StringArray4[]; + +type ClosedStringArray4Array StringArray4[3]; + +type StringArray5Array StringArray5[]; + +type ClosedStringArray5Array StringArray5[3]; + +type StringArray6Array StringArray5[]; + +type ClosedStringArray6Array StringArray5[3]; + +type FloatArray1Array FloatArray1[]; + +type ClosedFloatArray1Array FloatArray1[3]; + +type FloatArray2Array FloatArray2[]; + +type ClosedFloatArray2Array FloatArray2[3]; + +type FloatArray3Array FloatArray3[]; + +type ClosedFloatArray3Array FloatArray3[3]; + +type FloatArray4Array FloatArray4[]; + +type ClosedFloatArray4Array FloatArray4[3]; + +type FloatArray5Array FloatArray5[]; + +type ClosedFloatArray5Array FloatArray5[3]; + +type FloatArray6Array FloatArray5[]; + +type ClosedFloatArray6Array FloatArray5[3]; + +type DecimalArray1Array DecimalArray1[]; + +type ClosedDecimalArray1Array DecimalArray1[3]; + +type DecimalArray2Array DecimalArray2[]; + +type ClosedDecimalArray2Array DecimalArray2[3]; + +type DecimalArray3Array DecimalArray3[]; + +type ClosedDecimalArray3Array DecimalArray3[3]; + +type DecimalArray4Array DecimalArray4[]; + +type ClosedDecimalArray4Array DecimalArray4[3]; + +type DecimalArray5Array DecimalArray5[]; + +type ClosedDecimalArray5Array DecimalArray5[3]; + +type DecimalArray6Array DecimalArray5[]; + +type ClosedDecimalArray6Array DecimalArray5[3]; + +type BooleanArrayArray BooleanArray[]; + +type ClosedBooleanArrayArray BooleanArray[3]; + +type NillableBooleanArrayArray NillableBooleanArray[]; + +type NillableIntOrUnionBooleanArrayArray NillableIntOrUnionBooleanArray[]; + +type BooleanArray2Array BooleanArray2[]; + +type ClosedBooleanArray2Array BooleanArray2[3]; + +type BooleanArray3Array BooleanArray3[]; + +type ClosedBooleanArray3Array BooleanArray3[3]; + +type BooleanArray4Array BooleanArray4[]; + +type ClosedBooleanArray4Array BooleanArray4[3]; + +type BooleanArray5Array BooleanArray5[]; + +type ClosedBooleanArray5Array BooleanArray5[3]; + +type BooleanArray6Array BooleanArray5[]; + +type ClosedBooleanArray6Array BooleanArray5[3]; + +type NilArray1Array NilArray1[]; + +type ClosedNilArray1Array NilArray1[3]; + +type NilArray2Array NilArray2[]; + +type ClosedNilArray2Array NilArray2[3]; + +type NilArray3Array NilArray3[]; + +type ClosedNilArray3Array NilArray3[3]; + +type NilArray4Array NilArray4[]; + +type ClosedNilArray4Array NilArray4[3]; + +type NilArray5Array NilArray5[]; + +type ClosedNilArray5Array NilArray5[3]; + +type NilArray6Array NilArray5[]; + +type ClosedNilArray6Array NilArray5[3]; + +type JsonArray1Array JsonArray1[]; + +type ClosedJsonArray1Array JsonArray1[3]; + +type JsonArray2Array JsonArray2[]; + +type ClosedJsonArray2Array JsonArray2[3]; + +type JsonArray3Array JsonArray3[]; + +type ClosedJsonArray3Array JsonArray3[3]; + +type JsonArray4Array JsonArray4[]; + +type ClosedJsonArray4Array JsonArray4[3]; + +type JsonArray5Array JsonArray5[]; + +type ClosedJsonArray5Array JsonArray5[3]; + +type JsonArray6Array JsonArray5[]; + +type ClosedJsonArray6Array JsonArray5[3]; + +type AnydataArray1Array AnydataArray1[]; + +type ClosedAnydataArray1Array AnydataArray1[3]; + +type AnydataArray2Array AnydataArray2[]; + +type ClosedAnydataArray2Array AnydataArray2[3]; + +type AnydataArray3Array AnydataArray3[]; + +type ClosedAnydataArray3Array AnydataArray3[3]; + +type AnydataArray4Array AnydataArray4[]; + +type ClosedAnydataArray4Array AnydataArray4[3]; + +type AnydataArray5Array AnydataArray5[]; + +type ClosedAnydataArray5Array AnydataArray5[3]; + +type AnydataArray6Array AnydataArray5[]; + +type ClosedAnydataArray6Array AnydataArray5[3]; + +type CustomArray1Array CustomArray1[]; + +type ClosedCustomArray1Array CustomArray1[3]; + +type CustomArray2Array CustomArray2[]; + +type ClosedCustomArray2Array CustomArray2[3]; + +type CustomArray3Array CustomArray3[]; + +type ClosedCustomArray3Array CustomArray3[3]; + +type CustomArray4Array CustomArray4[]; + +type ClosedCustomArray4Array CustomArray4[3]; + +type CustomArray5Array CustomArray5[]; + +type ClosedCustomArray5Array CustomArray5[3]; + +type CustomArray6Array CustomArray5[]; + +type ClosedCustomArray6Array CustomArray5[3]; + +type IntegerMapArray IntegerMap[]; + +type ClosedIntegerMapArray IntegerMap[3]; + +type StringMapArray StringMap[]; + +type NillableIntUnionStringMapArray NillableIntUnionStringMap[]; + +type IntUnionStringMapArray IntUnionStringMap[]; + +type ClosedStringMapArray StringMap[3]; + +type DecimalMapArray DecimalMap[]; + +type ClosedDecimalMapArray DecimalMap[3]; + +type FloatMapArray FloatMap[]; + +type ClosedFloatMapArray FloatMap[3]; + +type BooleanMapArray BooleanMap[]; + +type NillableBooleanMapArray NillableBooleanMap[]; + +type NillableIntUnionBooleanMapArray NillableIntUnionBooleanMap[]; + +type IntUnionBooleanMapArray IntUnionBooleanMap[]; + +type ClosedBooleanMapArray BooleanMap[3]; + +type NilMapArray NilMap[]; + +type ClosedNilMapArray NilMap[3]; + +type JsonMapArray JsonMap[]; + +type ClosedJsonMapArray JsonMap[3]; + +type AnydataMapArray AnydataMap[]; + +type ClosedAnydataMapArray AnydataMap[3]; + +type CustomMapArray CustomMap[]; + +type ClosedCustomMapArray CustomMap[3]; + +type RecordWithCustomAnnotation record { + @Name { + value: "c" + } + int a; + int b; +}; + +type RecordWithCustomAnnotation2 record { + @Name { + value: "c" + } + int a?; + @Name { + value: "d" + } + int? b; +}; + +type RecordWithCustomAnnotation3 record {| + @Name { + value: "c" + } + int a?; + @Name { + value: "d" + } + int? b; +|}; + +type RecordWithCustomAnnotation4 record {| + @Name { + value: "c" + } + int a; + @Name { + value: "d" + } + int b; + boolean...; +|}; + +type RecordWithCustomAnnotation5 record { + @Name { + value: "c" + } + int a; + @Name { + value: "d" + } + int b; + int c?; +}; + +type RecordWithCustomAnnotation6 record { + @Name { + value: "c" + } + int a; + @Name { + value: "d" + } + int b; + @Name { + value: "e" + } + int c; +}; + +type RecordWithCustomAnnotation7 record { + @Name { + value: "c" + } + int a; + @Name { + value: "d" + } + int b; + @Name { + value: "a" + } + int c; +}; + +type RecordWithCustomAnnotation8 record { + @Name { + value: "c" + } + int a; + @Name { + value: "c" + } + int b; + @Name { + value: "a" + } + int c; +}; diff --git a/ballerina/types.bal b/ballerina/types.bal new file mode 100644 index 0000000..b708124 --- /dev/null +++ b/ballerina/types.bal @@ -0,0 +1,73 @@ +public type CsvConversionError error; + +# Defines the name of the JSON Object key. +# +# + value - The name of the JSON Object key +public type NameConfig record {| + string value; +|}; + +# The annotation is used to overwrite the existing record field name. +public const annotation NameConfig Name on record field; + +public type Options record { + record { + # If `true`, nil values will be considered as optional fields in the projection. + boolean nilAsOptionalField = false; // () assign to op + # If `true`, absent fields will be considered as nilable types in the projection. + boolean absentAsNilableType = false; // source haven't () && expected type contains op => () + }|false allowDataProjection = {}; + int[]|string skipLines = []; +}; + +public type ParseOption record {| + *Options; + string:Char delimiter = ","; + string encoding = "UTF-8"; + string locale = "en_US"; +// TODO: Add " for Strings" + string:Char textEnclosure = "\""; + string:Char escapeChar = "\\"; + LineTerminator|LineTerminator[] lineTerminator = [CR, LF, CRLF]; + NilValue? nilValue = (); + // string commentStartingSequence = "#"; + string:Char comment = "#"; + false|int:Unsigned32 header = 0; +|}; + +public type parseToRecordOption record {| + *ParseOption; + + // if header = false and this value is null, Then compiler time error. + string[]? customHeaders = (); + boolean enableConstraintValidation = true; +|}; + +public type ListAsListOption record {| + *Options; + boolean stringConversion = true; +|}; + +public type RecordAsRecordOption record {| + *Options; + boolean enableConstraintValidation = true; +|}; + +public type ListAsRecordOption record {| + *Options; + boolean enableConstraintValidation = true; + boolean stringConversion = true; +|}; + +public enum LineTerminator { + CR = "\r", + LF = "\n", + CRLF = "\r\n" +}; + +public enum NilValue { + NULL = "null", + EMPTY_STRING = "", + NOT_APPLICABLE = "N/A", + BAL_NULL = "()" +}; diff --git a/build-config/checkstyle/build.gradle b/build-config/checkstyle/build.gradle new file mode 100644 index 0000000..857ad1e --- /dev/null +++ b/build-config/checkstyle/build.gradle @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2020, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +plugins { + id "de.undercouch.download" +} + +apply plugin: 'java' + +task downloadCheckstyleRuleFiles(type: Download) { + src([ + 'https://raw.githubusercontent.com/wso2/code-quality-tools/v1.4/checkstyle/jdk-17/checkstyle.xml', + 'https://raw.githubusercontent.com/wso2/code-quality-tools/v1.4/checkstyle/jdk-17/suppressions.xml' + ]) + overwrite false + onlyIfNewer true + dest buildDir +} + +jar { + enabled = false +} + +clean { + enabled = false +} + +artifacts.add('default', file("$project.buildDir/checkstyle.csv")) { + builtBy('downloadCheckstyleRuleFiles') +} + +artifacts.add('default', file("$project.buildDir/suppressions.csv")) { + builtBy('downloadCheckstyleRuleFiles') +} diff --git a/build-config/resources/Ballerina.toml b/build-config/resources/Ballerina.toml new file mode 100644 index 0000000..ea02379 --- /dev/null +++ b/build-config/resources/Ballerina.toml @@ -0,0 +1,25 @@ +[package] +org = "ballerina" +name = "data.csv" +version = "@toml.version@" +authors = ["Ballerina"] +keywords = ["csv"] +repository = "https://github.com/ballerina-platform/module-ballerina-data.csv" +license = ["Apache-2.0"] +distribution = "2201.9.0" +export = ["data.csv"] + +[platform.java17] +graalvmCompatible = true + +[[platform.java17.dependency]] +groupId = "io.ballerina.stdlib" +artifactId = "data.csv-native" +version = "@toml.version@" +path = "../native/build/libs/data.csv-native-@project.version@.jar" + +[[platform.java17.dependency]] +groupId = "io.ballerina.stdlib" +artifactId = "constraint-native" +version = "@constraint.version@" +path = "./lib/constraint-native-@stdlib.constraintnative.version@.jar" diff --git a/build-config/resources/CompilerPlugin.toml b/build-config/resources/CompilerPlugin.toml new file mode 100644 index 0000000..10f4b4a --- /dev/null +++ b/build-config/resources/CompilerPlugin.toml @@ -0,0 +1,6 @@ +[plugin] +id = "constraint-compiler-plugin" +class = "io.ballerina.stdlib.data.csvdata.compiler.CsvDataCompilerPlugin" + +[[dependency]] +path = "../compiler-plugin/build/libs/data.csv-compiler-plugin-@project.version@.jar" diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..dc3d177 --- /dev/null +++ b/build.gradle @@ -0,0 +1,96 @@ +/** + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +plugins { + id "com.github.spotbugs" + id "com.github.johnrengelman.shadow" + id "de.undercouch.download" + id "net.researchgate.release" +} + +allprojects { + group = project.group + version = project.version + + apply plugin: 'jacoco' + apply plugin: 'maven-publish' + + repositories { + mavenLocal() + maven { + url = 'https://maven.wso2.org/nexus/content/repositories/releases/' + } + + maven { + url = 'https://maven.wso2.org/nexus/content/groups/wso2-public/' + } + + maven { + url = 'https://repo.maven.apache.org/maven2' + } + + maven { + url = 'https://maven.pkg.github.com/ballerina-platform/ballerina-lang' + credentials { + username System.getenv("packageUser") + password System.getenv("packagePAT") + } + } + } + + ext { + snapshotVersion= '-SNAPSHOT' + timestampedVersionRegex = '.*-\\d{8}-\\d{6}-\\w.*\$' + } +} + +subprojects { + + configurations { + ballerinaStdLibs + } + + dependencies { + /* Standard libraries */ + ballerinaStdLibs "io.ballerina.stdlib:file-ballerina:${stdlibFileVersion}" + ballerinaStdLibs "io.ballerina.stdlib:io-ballerina:${stdlibIoVersion}" + ballerinaStdLibs "io.ballerina.stdlib:os-ballerina:${stdlibOsVersion}" + ballerinaStdLibs "io.ballerina.stdlib:time-ballerina:${stdlibTimeVersion}" + ballerinaStdLibs "io.ballerina.stdlib:constraint-ballerina:${stdlibConstraintVersion}" + } +} + +def moduleVersion = project.version.replace("-SNAPSHOT", "") + +release { + failOnPublishNeeded = false + + buildTasks = ["build"] + failOnSnapshotDependencies = true + versionPropertyFile = 'gradle.properties' + tagTemplate = 'v$version' + + git { + requireBranch = "release-${moduleVersion}" + pushToRemote = 'origin' + } +} + +task build { + dependsOn('data.csv-ballerina:build') +} diff --git a/compiler-plugin-test/build.gradle b/compiler-plugin-test/build.gradle new file mode 100644 index 0000000..6d5c7f2 --- /dev/null +++ b/compiler-plugin-test/build.gradle @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +plugins { + id 'java' + id 'checkstyle' + id 'com.github.spotbugs' +} + +description = 'Ballerina - Csv Compiler Plugin Tests' + +dependencies { + checkstyle project(':checkstyle') + checkstyle "com.puppycrawl.tools:checkstyle:${puppycrawlCheckstyleVersion}" + + implementation project(':data.csv-compiler-plugin') + + testImplementation group: 'org.ballerinalang', name: 'ballerina-lang', version: "${ballerinaLangVersion}" + testImplementation group: 'org.ballerinalang', name: 'ballerina-tools-api', version: "${ballerinaLangVersion}" + testImplementation group: 'org.ballerinalang', name: 'ballerina-parser', version: "${ballerinaLangVersion}" + testImplementation group: 'org.testng', name: 'testng', version: "${testngVersion}" +} + +tasks.withType(Checkstyle) { + exclude '**/module-info.java' +} + +checkstyle { + toolVersion "${project.puppycrawlCheckstyleVersion}" + configFile rootProject.file("build-config/checkstyle/build/checkstyle.xml") + configProperties = ["suppressionFile" : file("${rootDir}/build-config/checkstyle/build/suppressions.xml")] +} + +checkstyleTest.dependsOn(":checkstyle:downloadCheckstyleRuleFiles") + +spotbugsTest { + effort "max" + reportLevel "low" + reportsDir = file("$project.buildDir/reports/spotbugs") + reports { + html.enabled true + text.enabled = true + } + def excludeFile = file("${project.projectDir}/spotbugs-exclude.xml") + if(excludeFile.exists()) { + excludeFilter = excludeFile + } +} + +spotbugsMain { + enabled false +} + +checkstyleMain { + enabled false +} + +compileJava { + doFirst { + options.compilerArgs = [ + '--module-path', classpath.asPath, + ] + classpath = files() + } +} + +test { + systemProperty "ballerina.offline.flag", "true" + useTestNG() + finalizedBy jacocoTestReport + + testLogging { + exceptionFormat = "full" + afterSuite { desc, result -> + if (!desc.parent) { // will match the outermost suite + def output = "Compiler Plugin Tests: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)" + def startItem = '| ', endItem = ' |' + def repeatLength = startItem.length() + output.length() + endItem.length() + println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength)) + } + } + } +} + +jacocoTestReport { + dependsOn test + reports { + xml.required = true + } + sourceSets project(':data.csv-compiler-plugin').sourceSets.main +} + +test.dependsOn ":data.csv-ballerina:build" diff --git a/compiler-plugin-test/src/test/java/io/ballerina/lib/data/csvdata/compiler/CompilerPluginTest.java b/compiler-plugin-test/src/test/java/io/ballerina/lib/data/csvdata/compiler/CompilerPluginTest.java new file mode 100644 index 0000000..69c212b --- /dev/null +++ b/compiler-plugin-test/src/test/java/io/ballerina/lib/data/csvdata/compiler/CompilerPluginTest.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package io.ballerina.lib.data.csvdata.compiler; + +/** + * This class includes tests for Ballerina Csv Data compiler plugin. + */ +public class CompilerPluginTest { + +} diff --git a/compiler-plugin-test/src/test/resources/testng.xml b/compiler-plugin-test/src/test/resources/testng.xml new file mode 100644 index 0000000..02c1d8e --- /dev/null +++ b/compiler-plugin-test/src/test/resources/testng.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + diff --git a/compiler-plugin/build.gradle b/compiler-plugin/build.gradle new file mode 100644 index 0000000..f30d515 --- /dev/null +++ b/compiler-plugin/build.gradle @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +plugins { + id 'java' + id 'checkstyle' + id 'com.github.spotbugs' +} + +description = 'Ballerina - Csv Data Compiler Plugin' + +dependencies { + checkstyle project(':checkstyle') + checkstyle "com.puppycrawl.tools:checkstyle:${puppycrawlCheckstyleVersion}" + + implementation group: 'org.ballerinalang', name: 'ballerina-lang', version: "${ballerinaLangVersion}" + implementation group: 'org.ballerinalang', name: 'ballerina-tools-api', version: "${ballerinaLangVersion}" + implementation group: 'org.ballerinalang', name: 'ballerina-parser', version: "${ballerinaLangVersion}" +} + +def excludePattern = '**/module-info.java' +tasks.withType(Checkstyle) { + exclude excludePattern +} + +checkstyle { + toolVersion "${project.puppycrawlCheckstyleVersion}" + configFile rootProject.file("build-config/checkstyle/build/checkstyle.xml") + configProperties = ["suppressionFile" : file("${rootDir}/build-config/checkstyle/build/suppressions.xml")] +} + +checkstyleMain.dependsOn(":checkstyle:downloadCheckstyleRuleFiles") + +spotbugsMain { + effort "max" + reportLevel "low" + reportsDir = file("$project.buildDir/reports/spotbugs") + reports { + html.enabled true + text.enabled = true + } + def excludeFile = file("${rootDir}/spotbugs-exclude.xml") + if(excludeFile.exists()) { + excludeFilter = excludeFile + } +} + +spotbugsMain { + enabled false +} + +compileJava { + doFirst { + options.compilerArgs = [ + '--module-path', classpath.asPath, + ] + classpath = files() + } +} diff --git a/compiler-plugin/src/main/java/io/ballerina/stdlib/data/csvdata/compiler/CsvDataCompilerPlugin.java b/compiler-plugin/src/main/java/io/ballerina/stdlib/data/csvdata/compiler/CsvDataCompilerPlugin.java new file mode 100644 index 0000000..80f28de --- /dev/null +++ b/compiler-plugin/src/main/java/io/ballerina/stdlib/data/csvdata/compiler/CsvDataCompilerPlugin.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package io.ballerina.stdlib.data.csvdata.compiler; + +import io.ballerina.projects.plugins.CompilerPlugin; +import io.ballerina.projects.plugins.CompilerPluginContext; + +/** + * Compiler plugin for Csvdata's utils functions. + * + * @since 0.1.0 + */ +public class CsvDataCompilerPlugin extends CompilerPlugin { + + @Override + public void init(CompilerPluginContext compilerPluginContext) { + + } +} diff --git a/compiler-plugin/src/main/java/module-info.java b/compiler-plugin/src/main/java/module-info.java new file mode 100644 index 0000000..58e15de --- /dev/null +++ b/compiler-plugin/src/main/java/module-info.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +module io.ballerina.stdlib.csvdata.compiler { + requires io.ballerina.lang; + requires io.ballerina.tools.api; + requires io.ballerina.parser; +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..ee77c50 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,23 @@ +org.gradle.caching=true +group=io.ballerina.stdlib +version=0.1.0-SNAPSHOT +ballerinaLangVersion=2201.9.0 + +checkstyleToolVersion=10.12.0 +puppycrawlCheckstyleVersion=10.12.0 +testngVersion=7.6.1 +slf4jVersion=2.0.7 +spotbugsVersion=5.0.14 +shadowJarPluginVersion=8.1.1 +downloadPluginVersion=4.0.4 +releasePluginVersion=2.8.0 +ballerinaGradlePluginVersion=2.0.1 +javaJsonPathVersion=2.9.0 +javaJsonSmartVersion=2.4.11 +javaAccessorsSmartVersion=2.4.7 + +stdlibFileVersion=1.9.0 +stdlibIoVersion=1.6.0 +stdlibOsVersion=1.8.0 +stdlibTimeVersion=2.4.0 +stdlibConstraintVersion=1.5.0 diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..7454180f2ae8848c63b8b4dea2cb829da983f2fa GIT binary patch literal 59536 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 QuEJmfE|#`Dqx|px0L@K;Y5)KL literal 0 HcmV?d00001 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..9f4197d --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.2.1-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100755 index 0000000..fcb6fca --- /dev/null +++ b/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..6689b85 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,92 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/native/build.gradle b/native/build.gradle new file mode 100644 index 0000000..54266fa --- /dev/null +++ b/native/build.gradle @@ -0,0 +1,80 @@ +/** + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +plugins { + id 'java' + id 'checkstyle' + id 'com.github.spotbugs' +} + +description = 'Ballerina - Data.CSV Java Utils' + +dependencies { + implementation 'junit:junit:4.13.1' +// checkstyle project(':checkstyle') + checkstyle "com.puppycrawl.tools:checkstyle:${puppycrawlCheckstyleVersion}" + implementation 'org.apache.commons:commons-lang3:3.6' + + implementation group: 'org.ballerinalang', name: 'ballerina-lang', version: "${ballerinaLangVersion}" + implementation group: 'org.ballerinalang', name: 'ballerina-runtime', version: "${ballerinaLangVersion}" + implementation group: 'org.ballerinalang', name: 'value', version: "${ballerinaLangVersion}" + implementation group: 'org.ballerinalang', name: 'value', version: "${ballerinaLangVersion}" + implementation group: 'io.ballerina.stdlib', name: 'constraint-native', version: "${stdlibConstraintVersion}" + // ballerinaStdLibs "io.ballerina.stdlib:constraint-ballerina:${stdlibConstraintVersion}" +} + +checkstyle { + toolVersion "${checkstyleToolVersion}" + configFile rootProject.file("build-config/checkstyle/build/checkstyle.xml") + configProperties = ["suppressionFile" : file("${rootDir}/build-config/checkstyle/build/suppressions.xml")] +} + +checkstyleMain.dependsOn(":checkstyle:downloadCheckstyleRuleFiles") + +def excludePattern = '**/module-info.java' +tasks.withType(Checkstyle) { + exclude excludePattern +} + +spotbugsMain { + enabled=false + effort "max" + reportLevel "low" + reportsDir = file("$project.buildDir/reports/spotbugs") + reports { + html.enabled true + text.enabled = true + } + def excludeFile = file("${rootDir}/spotbugs-exclude.csv") + if(excludeFile.exists()) { + excludeFilter = excludeFile + } +} + +spotbugsTest { + enabled = false +} + +compileJava { + doFirst { + options.compilerArgs = [ + '--module-path', classpath.asPath, + ] + classpath = files() + } +} diff --git a/native/src/main/java/io/ballerina/stdlib/data/csvdata/csv/Native.java b/native/src/main/java/io/ballerina/stdlib/data/csvdata/csv/Native.java new file mode 100644 index 0000000..1f5d3d6 --- /dev/null +++ b/native/src/main/java/io/ballerina/stdlib/data/csvdata/csv/Native.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package io.ballerina.stdlib.data.csvdata.csv; + +import io.ballerina.runtime.api.Environment; +import io.ballerina.runtime.api.values.BArray; +import io.ballerina.runtime.api.values.BMap; +import io.ballerina.runtime.api.values.BStream; +import io.ballerina.runtime.api.values.BString; +import io.ballerina.runtime.api.values.BTypedesc; + +/** + * Csv conversion. + * + * @since 0.1.0 + */ +public class Native { + + public static Object parseStringToRecord(BString csv, BMap options, BTypedesc type) { + return null; + } + + public static Object parseBytesToRecord(BArray csv, BMap options, BTypedesc type) { + return null; + } + + public static Object parseStreamToRecord(Environment env, BStream csv, + BMap options, BTypedesc type) { + return null; + } + + public static Object parseStringToList(BString csv, BMap options, BTypedesc type) { + return null; + } + + public static Object parseBytesToList(BArray csv, BMap options, BTypedesc type) { + return null; + } + + public static Object parseStreamToList(Environment env, BStream csv, + BMap options, BTypedesc type) { + return null; + } + + public static Object parseRecordAsRecordType(BArray csv, BMap options, BTypedesc type) { + return null; + } + + public static Object parseRecordAsListType(BArray csv, BArray headers, + BMap options, BTypedesc type) { + return null; + } + + public static Object parseListAsRecordType(BArray csv, Object customHeaders, + BMap options, BTypedesc type) { + return null; + } + + public static Object parseListAsListType(BArray csv, BMap options, BTypedesc type) { + return null; + } +} diff --git a/native/src/main/java/io/ballerina/stdlib/data/csvdata/utils/ModuleUtils.java b/native/src/main/java/io/ballerina/stdlib/data/csvdata/utils/ModuleUtils.java new file mode 100644 index 0000000..d9de709 --- /dev/null +++ b/native/src/main/java/io/ballerina/stdlib/data/csvdata/utils/ModuleUtils.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package io.ballerina.stdlib.data.csvdata.utils; + +import io.ballerina.runtime.api.Environment; +import io.ballerina.runtime.api.Module; + +/** + * This class will hold module related utility functions. + * + * @since 0.1.0 + */ +public class ModuleUtils { + + /** + * Time standard library package ID. + */ + private static Module module = null; + + private ModuleUtils() { + } + + public static void setModule(Environment env) { + module = env.getCurrentModule(); + } + + public static Module getModule() { + return module; + } +} diff --git a/native/src/main/java/module-info.java b/native/src/main/java/module-info.java new file mode 100644 index 0000000..1f625c2 --- /dev/null +++ b/native/src/main/java/module-info.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +module io.ballerina.stdlib.data { + requires io.ballerina.runtime; +} diff --git a/native/src/main/resources/error.properties b/native/src/main/resources/error.properties new file mode 100644 index 0000000..dc1471a --- /dev/null +++ b/native/src/main/resources/error.properties @@ -0,0 +1,100 @@ +# +# Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com). +# +# WSO2 LLC. licenses this file to you under the Apache License, +# Version 2.0 (the "License"); you may not use this file except +# in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +# ------------------------- +# Data module error messages +# ------------------------- + +error.invalid.type=\ + invalid expected type ''{0}'', expected a subtype of (map|anydata[])[] + +error.union.types.not.allowed.as.expected.type=\ + union types are not allowed in the expected type, found ''{0}'' + +error.invalid.array.member.in.expected.type=\ + invalid type ''{0}'' in the expected array type + +error.cannot.found.field.in.csv=\ + no matching header value is found for the required field ''{0}'' + +error.csv.value.cannot.cast.into.expected.type=\ + value ''{0}'' cannot be cast into ''{1}'' + +error.invalid.expected.type=\ + expected a array type, found ''{0}'' + +error.invalid.token.while.reading.the.csv.data=\ + error while reading the csv data ''{0}'' in line: ''{1}'', column: ''{2}'' + +error.invalid.csv.data.format=\ + invalid csv data format + +error.invalid.expected.array.size=\ + invalid array size for expected array type, cannot be greater than ''{0}'' + +error.invalid.expected.tuple.size=\ + invalid array size for expected tuple type, cannot be greater than ''{0}'' + +error.invalid.skip.column.query=\ + invalid query found for skip column field, ''{0}'' + +error.invalid.type.for.field=\ + no mapping type found for value ''{0}'' in key ''{1}'' + +error.invalid.type.for.array=\ + value ''{0}'' in index ''{1}'' is not compatible with array type ''{2}'' + +error.expected.type.can.only.contains.basic.types=\ + expected type cannot contains types other than basic types, ''{0}'' not allowed + +error.invalid.conversion.for.array.to.map=\ + value ''{0}'' cannot be cast into ''{1}'', because fields in ''{1}'' or the provided \ + expected headers are not matching with the ''{0}'' + +error.invalid.configurations=\ + invalid configurations: ''{0}'' + +error.invalid.format.for.skiplines=\ + Invalid format for the skipLines field. Expected format: 'start-end' + +error.invalid.range.for.skiplines=\ + Invalid range for the skipLines field. Start value must be less than or equal to end value. + +error.invalid.value.for.skiplines=\ + Invalid input for the skipLines field. Both start and end values must be integers. + +error.invalid.custom.header=\ + Invalid header value: ''{0}'' + +error.invalid.custom.header.length=\ + Invalid length for the custom headers + +error.invalid.header.names.length=\ + Invalid length for the header names + +error.header.cannot.be.empty=\ + The provided header row is empty + +error.no.field.for.header=\ + No mapping field in the expected type for header ''{0}'' + +error.duplicate.field=\ + Duplicate field found in record fields: ''{0}'' + +error.cannot.convert.into.exptype=\ + The source value cannot convert in to the ''{0}'' \ No newline at end of file diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..72b6bfd --- /dev/null +++ b/settings.gradle @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +pluginManagement { + plugins { + id "com.github.spotbugs" version "${spotbugsVersion}" + id "com.github.johnrengelman.shadow" version "${shadowJarPluginVersion}" + id "de.undercouch.download" version "${downloadPluginVersion}" + id "net.researchgate.release" version "${releasePluginVersion}" + id "io.ballerina.plugin" version "${ballerinaGradlePluginVersion}" + } + repositories { + gradlePluginPortal() + maven { + url = 'https://maven.pkg.github.com/ballerina-platform/*' + credentials { + username System.getenv("packageUser") + password System.getenv("packagePAT") + } + } + } +} + +plugins { + id "com.gradle.enterprise" version "3.2" +} + +rootProject.name = 'data.csv' +include(':checkstyle') +include(':data.csv-native') +include(':data.csv-ballerina') +include(':data.csv-compiler-plugin') +include(':data.csv-compiler-plugin-tests') + +project(':checkstyle').projectDir = file("build-config${File.separator}checkstyle") +project(':data.csv-native').projectDir = file('native') +project(':data.csv-ballerina').projectDir = file('ballerina') +project(':data.csv-compiler-plugin').projectDir = file('compiler-plugin') +project(':data.csv-compiler-plugin-tests').projectDir = file('compiler-plugin-test') + +gradleEnterprise { + buildScan { + termsOfServiceUrl = 'https://gradle.com/terms-of-service' + termsOfServiceAgree = 'yes' + } +} From 2e9de395a4a03bf97e2d2443b200677c46f546e6 Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Wed, 3 Jul 2024 14:21:50 +0530 Subject: [PATCH 2/9] Fix formatting issues in gradle files --- ballerina/build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ballerina/build.gradle b/ballerina/build.gradle index be27fbd..f81fe80 100644 --- a/ballerina/build.gradle +++ b/ballerina/build.gradle @@ -40,8 +40,8 @@ def packageOrg = "ballerina" def tomlVersion = stripBallerinaExtensionVersion("${project.version}") def ballerinaTomlFilePlaceHolder = new File("${project.rootDir}/build-config/resources/Ballerina.toml") def ballerinaTomlFile = new File("$project.projectDir/Ballerina.toml") - def compilerPluginTomlFilePlaceHolder = new File("${project.rootDir}/build-config/resources/CompilerPlugin.toml") - def compilerPluginTomlFile = new File("$project.projectDir/CompilerPlugin.toml") +def compilerPluginTomlFilePlaceHolder = new File("${project.rootDir}/build-config/resources/CompilerPlugin.toml") +def compilerPluginTomlFile = new File("$project.projectDir/CompilerPlugin.toml") def stripBallerinaExtensionVersion(String extVersion) { if (extVersion.matches(project.ext.timestampedVersionRegex)) { From e2bcc07d7042cc78b3d2cced7581e2a72f8cd930 Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Wed, 3 Jul 2024 14:43:29 +0530 Subject: [PATCH 3/9] Added api doc comments --- ballerina/build.gradle | 5 +- ballerina/csv_api.bal | 80 ++++++++++++++++--- ballerina/types.bal | 2 +- .../src/main/java/module-info.java | 2 +- 4 files changed, 75 insertions(+), 14 deletions(-) diff --git a/ballerina/build.gradle b/ballerina/build.gradle index f81fe80..4c5f9c3 100644 --- a/ballerina/build.gradle +++ b/ballerina/build.gradle @@ -82,8 +82,6 @@ task updateTomlFiles { def stdlibDependentConstraintVersion = stripBallerinaExtensionVersion("${stdlibDependentConstraintNativeVersion}") def newConfig = ballerinaTomlFilePlaceHolder.text.replace("@project.version@", project.version) newConfig = newConfig.replace("@toml.version@", tomlVersion) - newConfig = newConfig.replace("@stdlib.constraintnative.version@", stdlibDependentConstraintNativeVersion) - newConfig = newConfig.replace("@constraint.version@", stdlibDependentConstraintVersion) ballerinaTomlFile.text = newConfig def newCompilerPluginToml = compilerPluginTomlFilePlaceHolder.text.replace("@project.version@", project.version) @@ -141,3 +139,6 @@ build.dependsOn deleteDependencyTomlFiles test.dependsOn ":${packageName}-native:build" test.dependsOn ":${packageName}-native:build" test.dependsOn ":${packageName}-compiler-plugin:build" + +publish.dependsOn build +publishToMavenLocal.dependsOn build diff --git a/ballerina/csv_api.bal b/ballerina/csv_api.bal index ed6af24..db3fd88 100644 --- a/ballerina/csv_api.bal +++ b/ballerina/csv_api.bal @@ -16,37 +16,97 @@ import ballerina/jballerina.java; +# Converts CSV string to subtype of record array. +# +# + s - Source CSV string value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseStringToRecord(string s, parseToRecordOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Converts byte[] to subtype of record array. +# +# + s - Source CSV byte array +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseBytesToRecord(byte[] s, parseToRecordOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Converts CSV byte-block-stream to subtype of record array. +# +# + s - Source CSV byte-block-stream +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseStreamToRecord(stream s, parseToRecordOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Converts CSV string to subtype of anydata[][]. +# +# + s - Source CSV string value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseStringToList(string s, ParseOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Converts byte[] to subtype of anydata[][]. +# +# + s - Source CSV byte array +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseBytesToList(byte[] s, ParseOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Converts CSV byte-block-stream to subtype of anydata[][]. +# +# + s - Source CSV byte-block-stream +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseStreamToList(stream s, ParseOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Convert value of type `record{}[]` to subtype of `record{}[]`. +# +# + v - Source Ballerina record array value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseRecordAsRecordType(record{}[] s, RecordAsRecordOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Convert value of type `record{}[]` to subtype of `anydata[][]`. +# +# + v - Source Ballerina record array value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseRecordAsListType(record{}[] s, string[] headerNames, Options options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Convert value of type `string[][]` to subtype of `record{}[]`. +# +# + v - Source Ballerina string array of array value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseListAsRecordType(string[][] s, string[]? customHeaders = (), ListAsRecordOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; +# Convert value of type `string[][]` to subtype of `anydata[][]`. +# +# + v - Source Ballerina string array of array value +# + options - Options to be used for filtering in the projection +# + t - Target type +# + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. public isolated function parseListAsListType(string[][] s, ListAsListOption options = {}, typedesc t = <>) - returns t|CsvConversionError = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; + returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; diff --git a/ballerina/types.bal b/ballerina/types.bal index b708124..11b0c38 100644 --- a/ballerina/types.bal +++ b/ballerina/types.bal @@ -1,4 +1,4 @@ -public type CsvConversionError error; +public type Error error; # Defines the name of the JSON Object key. # diff --git a/compiler-plugin/src/main/java/module-info.java b/compiler-plugin/src/main/java/module-info.java index 58e15de..60ac711 100644 --- a/compiler-plugin/src/main/java/module-info.java +++ b/compiler-plugin/src/main/java/module-info.java @@ -20,4 +20,4 @@ requires io.ballerina.lang; requires io.ballerina.tools.api; requires io.ballerina.parser; -} \ No newline at end of file +} From 7144693ddacf2de216dec92131a48b72898682e3 Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 10:42:59 +0530 Subject: [PATCH 4/9] Remove the package md file --- ballerina/Package.md | 401 +-------------------- native/src/main/resources/error.properties | 79 ---- 2 files changed, 1 insertion(+), 479 deletions(-) diff --git a/ballerina/Package.md b/ballerina/Package.md index ea15954..7da4a1a 100644 --- a/ballerina/Package.md +++ b/ballerina/Package.md @@ -1,400 +1 @@ -# Package overview - -This package is designed to facilitate the handling and manipulation of CSV data within Ballerina applications. It streamlines the process of converting CSV data to native Ballerina data types, enabling developers to work with CSV content seamlessly and efficiently. - -This library is the refined successor of the `ballerina/csvdata` module, incorporating enhanced functionalities and improved performance. - -## Features - -- **Versatile CSV Data Input**: Accept CSV data as a csv, a string, byte array, or a stream and convert it into a Record value. -- **CSV to Record Value Conversion**: Transform CSV data into Ballerina records with ease in compliance with OpenAPI 3 standards. -- **Projection Support**: Perform selective conversion of CSV data subsets into Record values through projection. - -## Usage - -### Converting an CSV value to a Record value - -To convert an CSV value to a Record value, you can utilize the `fromCsvWithType` function provided by the library. The example below showcases the transformation of an CSV value into a Record value. - -```ballerina -import ballerina/data.csv as csvdata; -import ballerina/io; - -public function main() returns error? { - csv data = csv ` - 0 - string - string - `; - - Book book = check csvdata:fromCsvWithType(data, Book); - io:println(book); -} - -type Book record { - int id; - string title; - string author; -}; -``` - -### Converting an external CSV document to a Record value - -For transforming CSV content from an external source into a Record value, the `fromCsvStringWithType` function can be used. This external source can be in the form of a string or a byte array/byte stream that houses the CSV data. This is commonly extracted from files or network sockets. The example below demonstrates the conversion of an CSV value from an external source into a Record value. - -```ballerina -import ballerina/data.csv as csvdata; -import ballerina/io; - -public function main() returns error? { - string csvContent = check io:fileReadString("path/to/file.csv"); - Book book = check csvdata:fromCsvStringWithType(csvContent, Book); - io:println(book); -} - -type Book record { - int id; - string title; - string author; -}; -``` - -Make sure to handle possible errors that may arise during the file reading or CSV to record conversion process. The `check` keyword is utilized to handle these errors, but more sophisticated error handling can be implemented as per your requirements. - -## CSV to Record Canonical Representation - -The translation of CSV to a Record representation is a fundamental feature of the library. It facilitates a structured and type-safe approach to handling CSV data within Ballerina applications. - -Take for instance the following CSV snippet: - -```csv - - 0 - string - string - -``` - -CSV data is inherently hierarchical, forming a tree structure. In the given example, the root element is `book`, which encompasses three child elements: `id`, `title`, and `author`. The `id` element harbors a numeric value `0`, whereas both the `title` and `author` elements contain string values. - -A straightforward record representation of the above CSV data is: - -```ballerina -type Book record { - int id; - string title; - string author; -}; -``` - -In this representation, the CSV data is efficiently translated into a record value. The `book` element is mapped to a record of type `Book`, and the child elements `id`, `title`, and `author` are converted into record fields of types `int` and `string` correspondingly. - -This record type definition can be further refined through annotations. Moreover, utilizing open and closed records grants control over the translation process, which is elaborated in subsequent sections. - -### CSV Element Names - -The name of the CSV element serves as the name of the record field, altered to fit a valid Ballerina identifier. Notably, the record field name corresponds to the local name of the CSV element, with any namespace prefixes being disregarded. - -Consider the CSV snippet: - -```csv - - 0 - string - string - -``` - -The canonical representation of the above CSV as a Ballerina record is: - -```ballerina -type Book record { - int id; - string 'title\-name'; - string 'author\-name'; -}; -``` - -Observe how the CSV element names `title-name` and `author-name` are represented using delimited identifiers in Ballerina; the `-` characters in the CSV element names are escaped using the `\` character. - -Moreover, the `@Name` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process: - -```ballerina -import ballerina/data.csv as csvdata; - -type Book record { - int id; - @csvdata:Name { value: "title-name" } - string title; - @csvdata:Name { value: "author-name" } - string author; -}; -``` - -### CSV Attributes - -Similarly to CSV elements, CSV attributes are also represented into record fields within the corresponding parent Record type. The name of the CSV attribute is converted into the name of the record field, ensuring it is a valid Ballerina identifier. It is crucial to emphasize that the record field name aligns with the local name of the CSV attribute, and any namespace prefixes are ignored. - -Consider the following CSV snippet: - -```csv - - 0 - string - string - -``` - -The canonical representation of the above CSV as a Ballerina record is: - -```ballerina -type Book record { - string lang; - decimal price; - int id; - string title; - string author; -}; -``` - -Additionally the `@Attribute` annotation can be utilized to explicitly specify the name of the record field, providing control over the translation process. - -### Child Elements - -Child elements are mapped to record fields, with the type reflecting that of the corresponding child element. - -Examine the CSV snippet below: - -```csv - - 0 - string - - string - string - - -``` - -The canonical representation of the above CSV as a Ballerina record is: - -```ballerina -type Book record { - int id; - string title; - Author author; -}; - -type Author record { - string name; - string country; -}; -``` - -In this transformation, child elements, like the `author` element containing its own sub-elements, are converted into nested records. This maintains the hierarchical structure of the CSV data within the Ballerina type system, enabling intuitive and type-safe data manipulation. - -Alternatively, inline type definitions offer a compact method for representing child elements as records within their parent record. This approach is particularly beneficial when the child record does not require reuse elsewhere and is unique to its parent record. - -Consider the subsequent Ballerina record definition, which employs inline type definition for the `author` field: - -```ballerina -type Book record { - int id; - string title; - record { - string name; - string country; - } author; -}; -``` - -### CSV Text Content - -The transformation of CSV text content into record fields typically involves types like `string`, `boolean`, `int`, `float`, or `decimal`, depending on the textual content. For numeric values where type information is not explicitly defined, the default conversion type is `decimal`. Conversely, for non-numeric content, the default type is `string`. - -Consider the CSV snippet below: - -```csv - - 0 - string - string - true - 10.5 - -``` - -The translation into a Ballerina record would be as follows: - -```ballerina -type Book record { - int id; - string title; - string author; - boolean available; - decimal price; -}; -``` - -In scenarios where the parent CSV element of text content also includes attributes, the CSV text content can be represented by a `string` type field named `#content` within a record type, with the attributes being mapped to their respective fields. - -For instance, examine this CSV: - -```csv - - 0 - string - 10.5 - -``` - -The canonical translation of CSV to a Ballerina record is as such: - -```ballerina -type Book record { - int id; - Title title; - decimal price; -}; - -type Title record { - string \#content; - string lang; -}; -``` - -Modifications to the default behavior for converting numerical values can be achieved by providing `Options` mappings to the respective functions. This enables developers to choose specific data types and exert finer control over the conversion process. - -### CSV Namespaces - -CSV namespaces are accommodated by the library, supporting the translation of CSV data that contains namespace prefixes. However, the presence of CSV namespaces is not mandatory, and the library is capable of processing CSV data without namespaces. Should namespaces be present, they will be utilized to resolve the names of CSV elements and attributes. - -It's important to note that, unlike in the `csvdata` module, the namespace prefixes do not reflect in the record field names, as the record field names align with the local names of the CSV elements. - -Examine the CSV snippet below with default namespaces: - -```csv - - 0 - string - string - -``` - -The translation into a Ballerina record would be: - -```ballerina -type Book record { - int id; - string title; - string author; -}; -``` - -Incorporating namespace validation yields: - -```ballerina -import ballerina/data.csv as csvdata; - -@csvdata:Namespace { - uri: "http://example.com/book" -} -type Book record { - int id; - string title; - string author; -}; -``` - -Here is the same CSV snippet with a namespace prefix: - -```csv - - 0 - string - string - -``` - -The translation into a Ballerina record would be: - -```ballerina -import ballerina/data.csv as csvdata; - -@csvdata:Namespace { - uri: "http://example.com/book", - prefix: "bk" -} -type Book record { - int id; - string title; - string author; -}; -``` - -In these examples, the CSV namespaces are appropriately acknowledged, ensuring the integrity of the CSV structure within the Ballerina records. - -### Working with Arrays - -The library is equipped to handle the transformation of CSV data containing arrays into Ballerina records. - -Take the following CSV snippet as an example: - -```csv - - 0 - string - string - string - string - -``` - -The canonical representation of this CSV as a Ballerina record is: - -```ballerina -type Book record { - int id; - string title; - string[] author; -}; -``` - -### Controlling Which Elements to Convert - -The library allows for selective conversion of CSV elements into records through the use of rest fields. This is beneficial when the CSV data contains elements that are not necessary to be transformed into record fields. - -Take this CSV snippet as an example: - -```csv - - 0 - string - string - 10.5 - -``` - -Suppose that only the book `id`, and `title` elements are needed for conversion into record fields. This can be achieved by defining only the required fields in the record type and omitting the rest field: - -```ballerina -type Book record {| - int id; - string title; -|}; -``` - -However, if the rest field is utilized (or if the record type is defined as an open record), all elements in the CSV data will be transformed into record fields: - -```ballerina -type Book record { - int id; - string title; -}; -``` - -In this instance, all other elements in the CSV data, such as `author` and `price` along with their attributes, will be transformed into `string` type fields with the corresponding element name as the key. - -This behavior extends to arrays as well. - -The process of projecting CSV data into a record supports various use cases, including the filtering out of unnecessary elements. This functionality is anticipated to be enhanced in the future to accommodate more complex scenarios, such as filtering values based on regular expressions, among others. +# Ballerina CSV Data module \ No newline at end of file diff --git a/native/src/main/resources/error.properties b/native/src/main/resources/error.properties index dc1471a..84e78d6 100644 --- a/native/src/main/resources/error.properties +++ b/native/src/main/resources/error.properties @@ -19,82 +19,3 @@ # ------------------------- # Data module error messages # ------------------------- - -error.invalid.type=\ - invalid expected type ''{0}'', expected a subtype of (map|anydata[])[] - -error.union.types.not.allowed.as.expected.type=\ - union types are not allowed in the expected type, found ''{0}'' - -error.invalid.array.member.in.expected.type=\ - invalid type ''{0}'' in the expected array type - -error.cannot.found.field.in.csv=\ - no matching header value is found for the required field ''{0}'' - -error.csv.value.cannot.cast.into.expected.type=\ - value ''{0}'' cannot be cast into ''{1}'' - -error.invalid.expected.type=\ - expected a array type, found ''{0}'' - -error.invalid.token.while.reading.the.csv.data=\ - error while reading the csv data ''{0}'' in line: ''{1}'', column: ''{2}'' - -error.invalid.csv.data.format=\ - invalid csv data format - -error.invalid.expected.array.size=\ - invalid array size for expected array type, cannot be greater than ''{0}'' - -error.invalid.expected.tuple.size=\ - invalid array size for expected tuple type, cannot be greater than ''{0}'' - -error.invalid.skip.column.query=\ - invalid query found for skip column field, ''{0}'' - -error.invalid.type.for.field=\ - no mapping type found for value ''{0}'' in key ''{1}'' - -error.invalid.type.for.array=\ - value ''{0}'' in index ''{1}'' is not compatible with array type ''{2}'' - -error.expected.type.can.only.contains.basic.types=\ - expected type cannot contains types other than basic types, ''{0}'' not allowed - -error.invalid.conversion.for.array.to.map=\ - value ''{0}'' cannot be cast into ''{1}'', because fields in ''{1}'' or the provided \ - expected headers are not matching with the ''{0}'' - -error.invalid.configurations=\ - invalid configurations: ''{0}'' - -error.invalid.format.for.skiplines=\ - Invalid format for the skipLines field. Expected format: 'start-end' - -error.invalid.range.for.skiplines=\ - Invalid range for the skipLines field. Start value must be less than or equal to end value. - -error.invalid.value.for.skiplines=\ - Invalid input for the skipLines field. Both start and end values must be integers. - -error.invalid.custom.header=\ - Invalid header value: ''{0}'' - -error.invalid.custom.header.length=\ - Invalid length for the custom headers - -error.invalid.header.names.length=\ - Invalid length for the header names - -error.header.cannot.be.empty=\ - The provided header row is empty - -error.no.field.for.header=\ - No mapping field in the expected type for header ''{0}'' - -error.duplicate.field=\ - Duplicate field found in record fields: ''{0}'' - -error.cannot.convert.into.exptype=\ - The source value cannot convert in to the ''{0}'' \ No newline at end of file From 10cc4a1e9cfea81680f1d721e4297c20fb90b897 Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 10:43:50 +0530 Subject: [PATCH 5/9] [Automated] Update the native jar versions --- ballerina/Ballerina.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ballerina/Ballerina.toml b/ballerina/Ballerina.toml index f1d6945..c51f02f 100644 --- a/ballerina/Ballerina.toml +++ b/ballerina/Ballerina.toml @@ -21,5 +21,5 @@ path = "../native/build/libs/data.csv-native-0.1.0-SNAPSHOT.jar" [[platform.java17.dependency]] groupId = "io.ballerina.stdlib" artifactId = "constraint-native" -version = "1.5.0" -path = "./lib/constraint-native-1.5.0.jar" +version = "@constraint.version@" +path = "./lib/constraint-native-@stdlib.constraintnative.version@.jar" From 1d8b4a0ae51b026a810e628611fd6ece39a206a1 Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 10:48:19 +0530 Subject: [PATCH 6/9] Remove test types --- ballerina/tests/types.bal | 2634 ------------------------------------- 1 file changed, 2634 deletions(-) delete mode 100644 ballerina/tests/types.bal diff --git a/ballerina/tests/types.bal b/ballerina/tests/types.bal deleted file mode 100644 index 6a304ae..0000000 --- a/ballerina/tests/types.bal +++ /dev/null @@ -1,2634 +0,0 @@ -type BooleanRecord1 record { - boolean b1; - boolean|string b2; - boolean|string? b3; - boolean b4; -}; - -type BooleanRecord2 record {| - boolean b1; - boolean|string b2; - boolean|string? b3; - boolean b4; -|}; - -type BooleanRecord3 record {| - boolean b1; - boolean? b3; -|}; - -type BooleanRecord4 record { - boolean b1; - boolean? b3; -}; - -type BooleanRecord5 record { - boolean b1; - boolean? b3; - string defaultableField = ""; - string? nillableField = (); -}; - -type BooleanRecord6 record {| - boolean b1; - boolean? b3; - string defaultableField = ""; - string? nillableField = (); -|}; - -type BooleanRecord7 record { - boolean b1; - boolean? b3; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type BooleanRecord8 record {| - boolean b1; - boolean? b3; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type BooleanRecord9 record {| - boolean b1; - boolean? b3; - boolean?...; -|}; - -type BooleanRecord10 record {| - boolean...; -|}; - -type BooleanRecord11 record {| - boolean b1; - string defaultableField = ""; - string? nillableField = (); - boolean?|string...; -|}; - -type BooleanRecord12 record {| - boolean b1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - boolean...; -|}; - -type BooleanRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - string|boolean...; -|}; - -type BooleanRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - boolean...; -|}; - -type BooleanRecord15 record {| - int b1; - string defaultableField = ""; - string? nillableField = (); - boolean?...; -|}; - -type BooleanRecord16 record {| - boolean?...; -|}; - -type BooleanRecord17 record {| - int...; -|}; - -type BooleanRecord18 record {| - boolean b2; - int?...; -|}; - -type NilRecord1 record { - () n1; - () n2; - () n3; -}; - -type NilRecord2 record {| - () n1; - () n2; - () n3; -|}; - -type NilRecord3 record {| - () n1; - () n4; -|}; - -type NilRecord4 record { - () n1; - () n4; -}; - -type NilRecord5 record { - () n1; - () n4; - string defaultableField = ""; - string? nillableField = (); -}; - -type NilRecord6 record {| - () n1; - () n4; - string defaultableField = ""; - string? nillableField = (); -|}; - -type NilRecord7 record { - () n1; - () n4; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type NilRecord8 record {| - () n1; - () n4; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type NilRecord9 record {| - () n1; - () n2; - ()...; -|}; - -type NilRecord10 record {| - ()...; -|}; - -type NilRecord11 record {| - () n1; - string defaultableField = ""; - string? nillableField = (); - ()...; -|}; - -type NilRecord12 record {| - () n1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - ()...; -|}; - -type NilRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - ()...; -|}; - -type NilRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - ()...; -|}; - -type IntegerRecord1 record { - int i1; - int i2; - int i3; - int? i4; - int? i5; - int i6; - int i7; - int? i8; -}; - -type IntegerRecord2 record {| - int i1; - int? i2; - int i3; - int i4; - int? i5; - int i6; - int i7; - int? i8; -|}; - -type IntegerRecord3 record {| - int i1; - int i4; - int i6; -|}; - -type IntegerRecord4 record { - int i1; - int i4; - int i6; -}; - -type IntegerRecord5 record { - int i1; - int i4; - int i6; - string defaultableField = ""; - string? nillableField = (); -}; - -type IntegerRecord6 record {| - int i1; - int i4; - int i6; - string defaultableField = ""; - string? nillableField = (); -|}; - -type IntegerRecord7 record { - int i1; - int i4; - int i6; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type IntegerRecord8 record {| - int i1; - int i4; - int i6; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type IntegerRecord9 record {| - int i1; - int i2; - int...; -|}; - -type IntegerRecord10 record {| - int...; -|}; - -type IntegerRecord11 record {| - int i1; - string defaultableField = ""; - string? nillableField = (); - int...; -|}; - -type IntegerRecord12 record {| - int i1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - int...; -|}; - -type IntegerRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - int...; -|}; - -type IntegerRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - int...; -|}; - -type FloatRecord1 record { - float f1; - float f2; - float f3; - float f4; - float f5; - float f6; - float f7; - float f8; -}; - -type FloatRecord2 record {| - float f1; - float f2; - float f3; - float f4; - float f5; - float f6; - float f7; - float f8; -|}; - -type FloatRecord3 record {| - float f1; - float f4; - float f7; -|}; - -type FloatRecord4 record { - float f1; - float f4; - float f7; -}; - -type FloatRecord5 record { - float f1; - float f4; - float f7; - string defaultableField = ""; - string? nillableField = (); -}; - -type FloatRecord6 record {| - float f1; - float f4; - float f7; - string defaultableField = ""; - string? nillableField = (); -|}; - -type FloatRecord7 record { - float f1; - float f4; - float f7; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type FloatRecord8 record {| - float f1; - float f4; - float f7; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type FloatRecord9 record {| - float f1; - float f2; - float...; -|}; - -type FloatRecord10 record {| - float...; -|}; - -type FloatRecord11 record {| - float f1; - string defaultableField = ""; - string? nillableField = (); - float...; -|}; - -type FloatRecord12 record {| - float f1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - float...; -|}; - -type FloatRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - float...; -|}; - -type FloatRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - float...; -|}; - -type DecimalRecord1 record { - decimal d1; - decimal d2; - decimal d3; - decimal d4; - decimal d5; - decimal d6; - decimal d7; - decimal d8; -}; - -type DecimalRecord2 record {| - decimal d1; - decimal d2; - decimal d3; - decimal d4; - decimal d5; - decimal d6; - decimal d7; - decimal d8; -|}; - -type DecimalRecord3 record {| - decimal d1; - decimal d4; - decimal d7; -|}; - -type DecimalRecord4 record { - decimal d1; - decimal d4; - decimal d7; -}; - -type DecimalRecord5 record { - decimal d1; - decimal d4; - decimal d7; - string defaultableField = ""; - string? nillableField = (); -}; - -type DecimalRecord6 record {| - decimal d1; - decimal d4; - decimal d7; - string defaultableField = ""; - string? nillableField = (); -|}; - -type DecimalRecord7 record { - decimal d1; - decimal d4; - decimal d7; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type DecimalRecord8 record {| - decimal d1; - decimal d4; - decimal d7; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type DecimalRecord9 record {| - decimal d1; - decimal d2; - decimal...; -|}; - -type DecimalRecord10 record {| - decimal...; -|}; - -type DecimalRecord11 record {| - decimal d1; - string defaultableField = ""; - string? nillableField = (); - decimal...; -|}; - -type DecimalRecord12 record {| - decimal d1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - decimal...; -|}; - -type DecimalRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - decimal...; -|}; - -type DecimalRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - decimal...; -|}; - -type StringRecord1 record { - string s1; - string s2; - string s3; -}; - -type StringRecord2 record {| - string s1; - string s2; - string s3; -|}; - -type StringRecord3 record {| - string s1; - string s4; -|}; - -type StringRecord4 record { - string s1; - string s4; -}; - -type StringRecord5 record { - string s1; - string s4; - string defaultableField = ""; - string? nillableField = (); -}; - -type StringRecord6 record {| - string s1; - string s4; - string defaultableField = ""; - string? nillableField = (); -|}; - -type StringRecord7 record { - string s1; - string s4; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -}; - -type StringRecord8 record {| - string s1; - string s4; - string defaultableField = ""; - string? nillableField = (); - string requiredField; -|}; - -type StringRecord9 record {| - string s1; - string s2; - string...; -|}; - -type StringRecord10 record {| - string...; -|}; - -type StringRecord11 record {| - string s1; - string defaultableField = ""; - string? nillableField = (); - string...; -|}; - -type StringRecord12 record {| - string d1; - string defaultableField = ""; - string? nillableField = (); - string requiredField; - string...; -|}; - -type StringRecord13 record {| - string defaultableField = ""; - string? nillableField = (); - string...; -|}; - -type StringRecord14 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - string...; -|}; - -type StringRecord15 record {| - string defaultableField = ""; - string? nillableField = (); - string requiredField; - string...; -|}; - -type StringRecord16 record {| - string?...; -|}; - -type StringRecord17 record {| - int...; -|}; - -type StringRecord18 record {| - string b2; - int?...; -|}; - -type StringRecord19 record { - string s1 = ""; - string s2 = ""; -}; - -type StringRecord20 record {| - string s1 = ""; - string s2 = ""; -|}; - -type StringRecord21 record { -}; - -type StringRecord22 record {| - string s1 = ""; - string s2 = ""; - json...; -|}; - -type StringRecord23 record {| - json...; -|}; - -type JsonRecord1 record { - json j1; - json j2; - json j3; -}; - -type JsonRecord2 record {| - json j1; - json j2; - json j3; -|}; - -type JsonRecord3 record {| - json j1; - json j4; -|}; - -type JsonRecord4 record { - json j1; - json j4; -}; - -type JsonRecord5 record { - json j1; - json j4; - json defaultableField = ""; - json? nillableField = (); -}; - -type JsonRecord6 record {| - json j1; - json j4; - json defaultableField = ""; - json? nillableField = (); -|}; - -type JsonRecord7 record { - json j1; - json j4; - json defaultableField = ""; - json? nillableField = (); - json requiredField; -}; - -type JsonRecord8 record {| - json j1; - json j4; - json defaultableField = ""; - json? nillableField = (); - json requiredField; -|}; - -type JsonRecord9 record {| - json j1; - json j2; - json...; -|}; - -type JsonRecord10 record {| - json...; -|}; - -type JsonRecord11 record {| - json j1; - json defaultableField = ""; - json? nillableField = (); - json...; -|}; - -type JsonRecord12 record {| - json j1; - json defaultableField = ""; - json? nillableField = (); - json requiredField; - json...; -|}; - -type JsonRecord13 record {| - json defaultableField = ""; - json? nillableField = (); - json...; -|}; - -type JsonRecord14 record {| - json defaultableField = ""; - json? nillableField = (); - json requiredField; - json...; -|}; - -type AnydataRecord1 record { - anydata anydata1; - anydata anydata2; - anydata anydata3; -}; - -type AnydataRecord2 record {| - anydata anydata1; - anydata anydata2; - anydata anydata3; -|}; - -type AnydataRecord3 record {| - anydata anydata1; - anydata anydata4; -|}; - -type AnydataRecord4 record { - anydata anydata1; - anydata anydata4; -}; - -type AnydataRecord5 record { - anydata anydata1; - anydata anydata4; - anydata defaultableField = ""; - anydata? nillableField = (); -}; - -type AnydataRecord6 record {| - anydata anydata1; - anydata anydata4; - anydata defaultableField = ""; - anydata? nillableField = (); -|}; - -type AnydataRecord7 record { - anydata anydata1; - anydata anydata4; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; -}; - -type AnydataRecord8 record {| - anydata anydata1; - anydata anydata4; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; -|}; - -type AnydataRecord9 record {| - anydata anydata1; - anydata anydata2; - anydata...; -|}; - -type AnydataRecord10 record {| - anydata...; -|}; - -type AnydataRecord11 record {| - anydata anydata1; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata...; -|}; - -type AnydataRecord12 record {| - anydata anydata1; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; - anydata...; -|}; - -type AnydataRecord13 record {| - anydata defaultableField = ""; - anydata? nillableField = (); - anydata...; -|}; - -type AnydataRecord14 record {| - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; - anydata...; -|}; - -type CustomRecord1 record { - int i1; - int i2; - string s1; - string s2; - boolean b1; - boolean b2; - () n1; - () n2; - float f1; - float f2; - decimal d1; - decimal d2; -}; - -type CustomRecord2 record {| - int i1; - int i2; - string s1; - string s2; - boolean b1; - boolean b2; - () n1; - () n2; - float f1; - float f2; - decimal d1; - decimal d2; -|}; - -type CustomRecord3 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; -|}; - -type CustomRecord4 record { - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; -}; - -type CustomRecord5 record { - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - string defaultableField = ""; - string? nillableField = (); -}; - -type CustomRecord6 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata defaultableField = ""; - anydata? nillableField = (); -|}; - -type CustomRecord7 record { - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; -}; - -type CustomRecord8 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; -|}; - -type CustomRecord9 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - string...; -|}; - -type CustomRecord10 record {| - string...; -|}; - -type CustomRecord11 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata defaultableField = ""; - anydata? nillableField = (); - string...; -|}; - -type CustomRecord12 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; - string...; -|}; - -type CustomRecord13 record {| - anydata defaultableField = ""; - anydata? nillableField = (); - string...; -|}; - -type CustomRecord14 record {| - anydata defaultableField = ""; - anydata? nillableField = (); - anydata requiredField; - string...; -|}; - -type CustomRecord15 record {| - string '1; - string '2; -|}; - -type CustomRecord16 record {| - string '1; - string '2; - string '3; - string '4; -|}; - -type CustomRecord17 record { - string '1; - string '2; -}; - -type CustomRecord18 record { - string '1; - string '2; - string '3; - string '4; -}; - -type CustomRecord19 record { - string '1; - string '2; - string '3 = ""; - string '4 = ""; -}; - -type CustomRecord20 record { - string '1; -}; - -type CustomRecord21 record {| - string '1; - json...; -|}; - -type CustomRecord22 record {| - string '1; - string...; -|}; - -type CustomRecord23 record {| - string '1; - string a = ""; - string...; -|}; - -type CustomRecord24 record {| - string '1; - string '2 = ""; - string...; -|}; - -type CustomRecord25 record {| - int '1; - string...; -|}; - -type CustomRecord26 record {| - string '1; - int...; -|}; - -type CustomRecord27 record {| - int i1; - string s1; - boolean b1; - () n1; - float f1; - decimal d1; - anydata a1; - json j1; - anydata defaultableField = ""; - anydata? nillableField = (); - string...; -|}; - -type CustomRecord28 record { - string '1; -}; - -type CustomRecord29 record { - int '1; -}; - -type CustomRecord30 record {| - string '1; - string '2; - string '3; - string '4; - string '5; - string '6; -|}; - -type CustomRecord31 record {| - string '1; - string '6; -|}; - -type CustomRecord32 record {| - int '1; -|}; - -type CustomRecord33 record {| - string '1; - string '2; - string '3; - string '4; - string '5; - string '6; -|}; - -type CustomRecord34 record { - string '1; - string '6; - string '5 = ""; -}; - -type CustomRecord35 record { - string '1; - string '6; - string '9 = ""; -}; - -type CustomRecord36 record {| - string '1; - string '6; - string '9 = ""; -|}; - -type CustomRecord37 record {| - string '1; - string '6; - string '5 = ""; -|}; - -type CustomRecord38 record {| - string '1; - string '2; - string '3; - string '4; - string '5; - string '6; - string ...; -|}; - -type CustomRecord39 record {| - string '1; - string '2; - string '3; - string '4; - string '5; - string '6; - json ...; -|}; - -type CustomRecord40 record {| - string '5; - string '6; - json ...; -|}; - -type CustomRecord41 record {| - json ...; -|}; - -type CustomRecord42 record {| - int '1; - string '2; - boolean '3; - decimal '4; - float '5; - () '6; -|}; - -type CustomRecord43 record { - int '1; - string '2; - boolean '3; - decimal '4; - float '5; - () '6; -}; - -type CustomRecord44 record {| - int '1; - string '2; - boolean '3; - decimal '4; - float '5; - () '6; - string ...; -|}; - -type CustomRecord45 record {| - int H1; - string H2; - boolean H3; - decimal H4; - float H5; - () H6; -|}; - -type CustomRecord46 record { - int H1; - string H2; - boolean H3; - decimal H4; - float H5; - () H6; -}; - -type CustomRecord47 record {| - int H1; - string H2; - boolean H3; - decimal H4; - float H5; - () H6; - string ...; -|}; - -type CustomRecord48 record { - string H1; - string H2; - string H3; - string H4; - string H5; - string H6; -}; - -type CustomRecord49 record {| - string H1; - string H2; - string H3; - string H4; - string H5; - string H6; -|}; - -type CustomRecord50 record { - int H1; - float H4; -}; - -type CustomRecord51 record {| - int H1; - float H4; -|}; - -type CustomRecord52 record {| - string H1; - string H4; - string ...; -|}; - -type CustomRecord53 record {| - int H1; - float H4; - decimal ...; -|}; - -type CustomRecord54 record {| - string H1 = ""; - string H4; - string '1; -|}; - -type CustomRecord55 record {| - string H1 = ""; - string H4 = ""; - int '1 = 10; -|}; - -type CustomRecord56 record { - string H1 = ""; - string H4 = ""; - anydata '1 = 10; -}; - -type BooleanTuple1 [boolean, boolean, boolean, boolean]; - -type BooleanTuple2 [boolean, boolean]; - -type BooleanTuple3 [boolean, boolean...]; - -type BooleanTuple4 [boolean...]; - -type NillableBooleanTuple5 [boolean?, boolean?, boolean?, boolean?, boolean?]; - -type NillableBooleanTuple6 [boolean?, boolean?]; - -type NillableBooleanTuple7 [boolean?, boolean?, boolean?...]; - -type NillableBooleanTuple8 [boolean?...]; - -type NillableIntBooleanTuple9 [int|boolean?, int|boolean?...]; - -type NilTuple1 [(), (), ()]; - -type NilTuple2 [(), ()]; - -type NilTuple3 [(), ()...]; - -type NilTuple4 [()...]; - -type IntegerTuple1 [int, int, int, int, int, int]; - -type IntegerTuple2 [int, int]; - -type IntegerTuple3 [int, int...]; - -type IntegerTuple4 [int...]; - -type FloatTuple1 [float, float, float, float, float, float, float]; - -type FloatTuple2 [float, float]; - -type FloatTuple3 [float, float...]; - -type FloatTuple4 [float...]; - -type DecimalTuple1 [decimal, decimal, decimal, decimal]; - -type DecimalTuple2 [decimal, decimal]; - -type DecimalTuple3 [decimal, decimal...]; - -type DecimalTuple4 [decimal...]; - -type StringTuple1 [string, string, string, string]; - -type StringTuple2 [string, string]; - -type StringTuple3 [string, string...]; - -type StringTuple4 [string...]; - -type AnydataTuple1 [anydata, anydata, anydata, anydata, anydata, - anydata, anydata, anydata, anydata, anydata, anydata, anydata, - anydata, anydata, anydata, anydata, anydata, anydata, anydata, - anydata, anydata, anydata, anydata]; - -type AnydataTuple2 [anydata, anydata]; - -type AnydataTuple3 [anydata, anydata...]; - -type AnydataTuple4 [anydata...]; - -type JsonTuple1 [json, json, json, json, json, json, json, json, - json, json, json, json, json, json, json, json, json, json, - json, json, json, json, json]; - -type JsonTuple2 [json, json]; - -type JsonTuple3 [json, json...]; - -type JsonTuple4 [json...]; - -type CustomTuple1 [string, int, decimal, float, (), boolean, anydata, json, string, int, decimal, float, (), boolean, anydata, json]; - -type CustomTuple2 [string, int, decimal, float, (), boolean, anydata, json]; - -type CustomTuple3 [string, int, decimal, float, (), boolean, anydata, json, string...]; - -type CustomTuple4 [string...]; - -type CustomTuple5 [string, int, decimal, float, (), boolean, anydata, json, anydata...]; - -type CustomTuple6 [anydata...]; - -type CustomTuple7 [int, string, boolean, (), float, decimal, json, anydata, string...]; - -type CustomTuple8 [int, string, boolean, (), float, decimal, json, anydata, int...]; - -type IntegerArray1 int[]; - -type IntegerArray2 int[2]; - -type IntegerArray3 int[]; - -type IntegerArray4 int[2]; - -type IntegerArray5 int[3]; - -type IntegerArray6 int[4]; - -type StringArray string[]; - -type NillableStringArray string?[]; - -type NillableIntOrUnionStringArray (int|string?)[]; - -type StringArray1 string[]; - -type StringArray2 string[2]; - -type StringArray3 string[]; - -type StringArray4 string[2]; - -type StringArray5 string[3]; - -type StringArray6 string[4]; - -type FloatArray1 float[]; - -type FloatArray2 float[2]; - -type FloatArray3 float[]; - -type FloatArray4 float[2]; - -type FloatArray5 float[3]; - -type FloatArray6 float[4]; - -type DecimalArray1 decimal[]; - -type DecimalArray2 decimal[2]; - -type DecimalArray3 decimal[]; - -type DecimalArray4 decimal[2]; - -type DecimalArray5 decimal[3]; - -type DecimalArray6 decimal[4]; - -type BooleanArray boolean[]; - -type NillableBooleanArray boolean?[]; - -type NillableIntOrUnionBooleanArray (int|boolean?)[]; - -type BooleanArray2 boolean[2]; - -type BooleanArray3 boolean[3]; - -type BooleanArray4 boolean[]; - -type BooleanArray5 boolean[2]; - -type BooleanArray6 boolean[4]; - -type NilArray1 ()[]; - -type NilArray2 ()[2]; - -type NilArray3 ()[]; - -type NilArray4 ()[2]; - -type NilArray5 ()[3]; - -type NilArray6 ()[4]; - -type JsonArray1 json[]; - -type JsonArray2 json[2]; - -type JsonArray3 json[]; - -type JsonArray4 json[2]; - -type JsonArray5 json[3]; - -type JsonArray6 json[4]; - -type AnydataArray1 anydata[]; - -type AnydataArray2 anydata[2]; - -type AnydataArray3 anydata[]; - -type AnydataArray4 anydata[2]; - -type AnydataArray5 anydata[3]; - -type AnydataArray6 anydata[4]; - -type CustomArray1 CustomTuple2[]; - -type CustomArray2 CustomTuple2[2]; - -type CustomArray3 CustomTuple2[]; - -type CustomArray4 CustomTuple2[2]; - -type CustomArray5 CustomTuple2[3]; - -type CustomArray6 CustomTuple2[4]; - -type IntegerMap map; - -type StringMap map; - -type NillableIntUnionStringMap map; - -type IntUnionStringMap map; - -type DecimalMap map; - -type FloatMap map; - -type BooleanMap map; - -type NillableBooleanMap map; - -type NillableIntUnionBooleanMap map; - -type IntUnionBooleanMap map; - -type NilMap map<()>; - -type JsonMap map; - -type AnydataMap map; - -type CustomMap map; - -type BooleanRecord1Array BooleanRecord1[]; - -type ClosedBooleanRecord1Array BooleanRecord1[3]; - -type BooleanRecord2Array BooleanRecord2[]; - -type ClosedBooleanRecord2Array BooleanRecord2[3]; - -type BooleanRecord3Array BooleanRecord3[]; - -type ClosedBooleanRecord3Array BooleanRecord3[3]; - -type BooleanRecord4Array BooleanRecord4[]; - -type ClosedBooleanRecord4Array BooleanRecord4[3]; - -type BooleanRecord5Array BooleanRecord5[]; - -type ClosedBooleanRecord5Array BooleanRecord5[3]; - -type BooleanRecord6Array BooleanRecord6[]; - -type ClosedBooleanRecord6Array BooleanRecord6[3]; - -type BooleanRecord7Array BooleanRecord7[]; - -type ClosedBooleanRecord7Array BooleanRecord7[3]; - -type BooleanRecord8Array BooleanRecord8[]; - -type ClosedBooleanRecord8Array BooleanRecord8[3]; - -type BooleanRecord9Array BooleanRecord9[]; - -type ClosedBooleanRecord9Array BooleanRecord9[3]; - -type BooleanRecord10Array BooleanRecord10[]; - -type ClosedBooleanRecord10Array BooleanRecord10[3]; - -type BooleanRecord11Array BooleanRecord11[]; - -type ClosedBooleanRecord11Array BooleanRecord11[3]; - -type BooleanRecord12Array BooleanRecord12[]; - -type ClosedBooleanRecord12Array BooleanRecord12[3]; - -type BooleanRecord13Array BooleanRecord13[]; - -type ClosedBooleanRecord13Array BooleanRecord13[3]; - -type BooleanRecord14Array BooleanRecord14[]; - -type ClosedBooleanRecord14Array BooleanRecord14[3]; - -type BooleanRecord15Array BooleanRecord15[]; - -type ClosedBooleanRecord15Array BooleanRecord15[3]; - -type BooleanRecord16Array BooleanRecord16[]; - -type ClosedBooleanRecord16Array BooleanRecord16[3]; - -type BooleanRecord17Array BooleanRecord17[]; - -type ClosedBooleanRecord17Array BooleanRecord17[3]; - -type BooleanRecord18Array BooleanRecord18[]; - -type ClosedBooleanRecord18Array BooleanRecord18[3]; - -type NilRecord1Array NilRecord1[]; - -type ClosedNilRecord1Array NilRecord1[3]; - -type NilRecord2Array NilRecord2[]; - -type ClosedNilRecord2Array NilRecord2[3]; - -type NilRecord3Array NilRecord3[]; - -type ClosedNilRecord3Array NilRecord3[3]; - -type NilRecord4Array NilRecord4[]; - -type ClosedNilRecord4Array NilRecord4[3]; - -type NilRecord5Array NilRecord5[]; - -type ClosedNilRecord5Array NilRecord5[3]; - -type NilRecord6Array NilRecord6[]; - -type ClosedNilRecord6Array NilRecord6[3]; - -type NilRecord7Array NilRecord7[]; - -type ClosedNilRecord7Array NilRecord7[3]; - -type NilRecord8Array NilRecord8[]; - -type ClosedNilRecord8Array NilRecord8[3]; - -type NilRecord9Array NilRecord9[]; - -type ClosedNilRecord9Array NilRecord9[3]; - -type NilRecord10Array NilRecord10[]; - -type ClosedNilRecord10Array NilRecord10[3]; - -type NilRecord11Array NilRecord11[]; - -type ClosedNilRecord11Array NilRecord11[3]; - -type NilRecord12Array NilRecord12[]; - -type ClosedNilRecord12Array NilRecord12[3]; - -type NilRecord13Array NilRecord13[]; - -type ClosedNilRecord13Array NilRecord13[3]; - -type NilRecord14Array NilRecord14[]; - -type ClosedNilRecord14Array NilRecord14[3]; - -type IntegerRecord1Array IntegerRecord1[]; - -type ClosedIntegerRecord1Array IntegerRecord1[3]; - -type IntegerRecord2Array IntegerRecord2[]; - -type ClosedIntegerRecord2Array IntegerRecord2[3]; - -type IntegerRecord3Array IntegerRecord3[]; - -type ClosedIntegerRecord3Array IntegerRecord3[3]; - -type IntegerRecord4Array IntegerRecord4[]; - -type ClosedIntegerRecord4Array IntegerRecord4[3]; - -type IntegerRecord5Array IntegerRecord5[]; - -type ClosedIntegerRecord5Array IntegerRecord5[3]; - -type IntegerRecord6Array IntegerRecord6[]; - -type ClosedIntegerRecord6Array IntegerRecord6[3]; - -type IntegerRecord7Array IntegerRecord7[]; - -type ClosedIntegerRecord7Array IntegerRecord7[3]; - -type IntegerRecord8Array IntegerRecord8[]; - -type ClosedIntegerRecord8Array IntegerRecord8[3]; - -type IntegerRecord9Array IntegerRecord9[]; - -type ClosedIntegerRecord9Array IntegerRecord9[3]; - -type IntegerRecord10Array IntegerRecord10[]; - -type ClosedIntegerRecord10Array IntegerRecord10[3]; - -type IntegerRecord11Array IntegerRecord11[]; - -type ClosedIntegerRecord11Array IntegerRecord11[3]; - -type IntegerRecord12Array IntegerRecord12[]; - -type ClosedIntegerRecord12Array IntegerRecord12[3]; - -type IntegerRecord13Array IntegerRecord13[]; - -type ClosedIntegerRecord13Array IntegerRecord13[3]; - -type IntegerRecord14Array IntegerRecord14[]; - -type ClosedIntegerRecord14Array IntegerRecord14[3]; - -type FloatRecord1Array FloatRecord1[]; - -type ClosedFloatRecord1Array FloatRecord1[3]; - -type FloatRecord2Array FloatRecord2[]; - -type ClosedFloatRecord2Array FloatRecord2[3]; - -type FloatRecord3Array FloatRecord3[]; - -type ClosedFloatRecord3Array FloatRecord3[3]; - -type FloatRecord4Array FloatRecord4[]; - -type ClosedFloatRecord4Array FloatRecord4[3]; - -type FloatRecord5Array FloatRecord5[]; - -type ClosedFloatRecord5Array FloatRecord5[3]; - -type FloatRecord6Array FloatRecord6[]; - -type ClosedFloatRecord6Array FloatRecord6[3]; - -type FloatRecord7Array FloatRecord7[]; - -type ClosedFloatRecord7Array FloatRecord7[3]; - -type FloatRecord8Array FloatRecord8[]; - -type ClosedFloatRecord8Array FloatRecord8[3]; - -type FloatRecord9Array FloatRecord9[]; - -type ClosedFloatRecord9Array FloatRecord9[3]; - -type FloatRecord10Array FloatRecord10[]; - -type ClosedFloatRecord10Array FloatRecord10[3]; - -type FloatRecord11Array FloatRecord11[]; - -type ClosedFloatRecord11Array FloatRecord11[3]; - -type FloatRecord12Array FloatRecord12[]; - -type ClosedFloatRecord12Array FloatRecord12[3]; - -type FloatRecord13Array FloatRecord13[]; - -type ClosedFloatRecord13Array FloatRecord13[3]; - -type FloatRecord14Array FloatRecord14[]; - -type ClosedFloatRecord14Array FloatRecord14[3]; - -type DecimalRecord1Array DecimalRecord1[]; - -type ClosedDecimalRecord1Array DecimalRecord1[3]; - -type DecimalRecord2Array DecimalRecord2[]; - -type ClosedDecimalRecord2Array DecimalRecord2[3]; - -type DecimalRecord3Array DecimalRecord3[]; - -type ClosedDecimalRecord3Array DecimalRecord3[3]; - -type DecimalRecord4Array DecimalRecord4[]; - -type ClosedDecimalRecord4Array DecimalRecord4[3]; - -type DecimalRecord5Array DecimalRecord5[]; - -type ClosedDecimalRecord5Array DecimalRecord5[3]; - -type DecimalRecord6Array DecimalRecord6[]; - -type ClosedDecimalRecord6Array DecimalRecord6[3]; - -type DecimalRecord7Array DecimalRecord7[]; - -type ClosedDecimalRecord7Array DecimalRecord7[3]; - -type DecimalRecord8Array DecimalRecord8[]; - -type ClosedDecimalRecord8Array DecimalRecord8[3]; - -type DecimalRecord9Array DecimalRecord9[]; - -type ClosedDecimalRecord9Array DecimalRecord9[3]; - -type DecimalRecord10Array DecimalRecord10[]; - -type ClosedDecimalRecord10Array DecimalRecord10[3]; - -type DecimalRecord11Array DecimalRecord11[]; - -type ClosedDecimalRecord11Array DecimalRecord11[3]; - -type DecimalRecord12Array DecimalRecord12[]; - -type ClosedDecimalRecord12Array DecimalRecord12[3]; - -type DecimalRecord13Array DecimalRecord13[]; - -type ClosedDecimalRecord13Array DecimalRecord13[3]; - -type DecimalRecord14Array DecimalRecord14[]; - -type ClosedDecimalRecord14Array DecimalRecord14[3]; - -type StringRecord1Array StringRecord1[]; - -type ClosedStringRecord1Array StringRecord1[3]; - -type StringRecord2Array StringRecord2[]; - -type ClosedStringRecord2Array StringRecord2[3]; - -type StringRecord3Array StringRecord3[]; - -type ClosedStringRecord3Array StringRecord3[3]; - -type StringRecord4Array StringRecord4[]; - -type ClosedStringRecord4Array StringRecord4[3]; - -type StringRecord5Array StringRecord5[]; - -type ClosedStringRecord5Array StringRecord5[3]; - -type StringRecord6Array StringRecord6[]; - -type ClosedStringRecord6Array StringRecord6[3]; - -type StringRecord7Array StringRecord7[]; - -type ClosedStringRecord7Array StringRecord7[3]; - -type StringRecord8Array StringRecord8[]; - -type ClosedStringRecord8Array StringRecord8[3]; - -type StringRecord9Array StringRecord9[]; - -type ClosedStringRecord9Array StringRecord9[3]; - -type StringRecord10Array StringRecord10[]; - -type ClosedStringRecord10Array StringRecord10[3]; - -type StringRecord11Array StringRecord11[]; - -type ClosedStringRecord11Array StringRecord11[3]; - -type StringRecord12Array StringRecord12[]; - -type ClosedStringRecord12Array StringRecord12[3]; - -type StringRecord13Array StringRecord13[]; - -type ClosedStringRecord13Array StringRecord13[3]; - -type StringRecord14Array StringRecord14[]; - -type ClosedStringRecord14Array StringRecord14[3]; - -type StringRecord15Array StringRecord15[]; - -type StringRecord16Array StringRecord16[]; - -type StringRecord17Array StringRecord17[]; - -type StringRecord18Array StringRecord18[]; - -type StringRecord19Array StringRecord19[]; - -type StringRecord20Array StringRecord20[]; - -type StringRecord21Array StringRecord21[]; - -type StringRecord22Array StringRecord22[]; - -type StringRecord23Array StringRecord23[]; - -type JsonRecord1Array JsonRecord1[]; - -type ClosedJsonRecord1Array JsonRecord1[3]; - -type JsonRecord2Array JsonRecord2[]; - -type ClosedJsonRecord2Array JsonRecord2[3]; - -type JsonRecord3Array JsonRecord3[]; - -type ClosedJsonRecord3Array JsonRecord3[3]; - -type JsonRecord4Array JsonRecord4[]; - -type ClosedJsonRecord4Array JsonRecord4[3]; - -type JsonRecord5Array JsonRecord5[]; - -type ClosedJsonRecord5Array JsonRecord5[3]; - -type JsonRecord6Array JsonRecord6[]; - -type ClosedJsonRecord6Array JsonRecord6[3]; - -type JsonRecord7Array JsonRecord7[]; - -type ClosedJsonRecord7Array JsonRecord7[3]; - -type JsonRecord8Array JsonRecord8[]; - -type ClosedJsonRecord8Array JsonRecord8[3]; - -type JsonRecord9Array JsonRecord9[]; - -type ClosedJsonRecord9Array JsonRecord9[3]; - -type JsonRecord10Array JsonRecord10[]; - -type ClosedJsonRecord10Array JsonRecord10[3]; - -type JsonRecord11Array JsonRecord11[]; - -type ClosedJsonRecord11Array JsonRecord11[3]; - -type JsonRecord12Array JsonRecord12[]; - -type ClosedJsonRecord12Array JsonRecord12[3]; - -type JsonRecord13Array JsonRecord13[]; - -type ClosedJsonRecord13Array JsonRecord13[3]; - -type JsonRecord14Array JsonRecord14[]; - -type ClosedJsonRecord14Array JsonRecord14[3]; - -type AnydataRecord1Array AnydataRecord1[]; - -type ClosedAnydataRecord1Array AnydataRecord1[3]; - -type AnydataRecord2Array AnydataRecord2[]; - -type ClosedAnydataRecord2Array AnydataRecord2[3]; - -type AnydataRecord3Array AnydataRecord3[]; - -type ClosedAnydataRecord3Array AnydataRecord3[3]; - -type AnydataRecord4Array AnydataRecord4[]; - -type ClosedAnydataRecord4Array AnydataRecord4[3]; - -type AnydataRecord5Array AnydataRecord5[]; - -type ClosedAnydataRecord5Array AnydataRecord5[3]; - -type AnydataRecord6Array AnydataRecord6[]; - -type ClosedAnydataRecord6Array AnydataRecord6[3]; - -type AnydataRecord7Array AnydataRecord7[]; - -type ClosedAnydataRecord7Array AnydataRecord7[3]; - -type AnydataRecord8Array AnydataRecord8[]; - -type ClosedAnydataRecord8Array AnydataRecord8[3]; - -type AnydataRecord9Array AnydataRecord9[]; - -type ClosedAnydataRecord9Array AnydataRecord9[3]; - -type AnydataRecord10Array AnydataRecord10[]; - -type ClosedAnydataRecord10Array AnydataRecord10[3]; - -type AnydataRecord11Array AnydataRecord11[]; - -type ClosedAnydataRecord11Array AnydataRecord11[3]; - -type AnydataRecord12Array AnydataRecord12[]; - -type ClosedAnydataRecord12Array AnydataRecord12[3]; - -type AnydataRecord13Array AnydataRecord13[]; - -type ClosedAnydataRecord13Array AnydataRecord13[3]; - -type AnydataRecord14Array AnydataRecord14[]; - -type ClosedAnydataRecord14Array AnydataRecord14[3]; - -type CustomRecord1Array CustomRecord1[]; - -type ClosedCustomRecord1Array CustomRecord1[3]; - -type CustomRecord2Array CustomRecord2[]; - -type ClosedCustomRecord2Array CustomRecord2[3]; - -type CustomRecord3Array CustomRecord3[]; - -type ClosedCustomRecord3Array CustomRecord3[3]; - -type CustomRecord4Array CustomRecord4[]; - -type ClosedCustomRecord4Array CustomRecord4[3]; - -type CustomRecord5Array CustomRecord5[]; - -type ClosedCustomRecord5Array CustomRecord5[3]; - -type CustomRecord6Array CustomRecord6[]; - -type ClosedCustomRecord6Array CustomRecord6[3]; - -type CustomRecord7Array CustomRecord7[]; - -type ClosedCustomRecord7Array CustomRecord7[3]; - -type CustomRecord8Array CustomRecord8[]; - -type ClosedCustomRecord8Array CustomRecord8[3]; - -type CustomRecord9Array CustomRecord9[]; - -type ClosedCustomRecord9Array CustomRecord9[3]; - -type CustomRecord10Array CustomRecord10[]; - -type ClosedCustomRecord10Array CustomRecord10[3]; - -type CustomRecord11Array CustomRecord11[]; - -type ClosedCustomRecord11Array CustomRecord11[3]; - -type CustomRecord12Array CustomRecord12[]; - -type ClosedCustomRecord12Array CustomRecord12[3]; - -type CustomRecord13Array CustomRecord13[]; - -type ClosedCustomRecord13Array CustomRecord13[3]; - -type CustomRecord14Array CustomRecord14[]; - -type ClosedCustomRecord14Array CustomRecord14[3]; - -type CustomRecord15Array CustomRecord15[]; - -type CustomRecord16Array CustomRecord16[]; - -type CustomRecord17Array CustomRecord17[]; - -type CustomRecord18Array CustomRecord18[]; - -type CustomRecord19Array CustomRecord19[]; - -type CustomRecord20Array CustomRecord20[]; - -type CustomRecord21Array CustomRecord21[]; - -type CustomRecord22Array CustomRecord22[]; - -type CustomRecord23Array CustomRecord23[]; - -type CustomRecord24Array CustomRecord24[]; - -type CustomRecord25Array CustomRecord25[]; - -type CustomRecord26Array CustomRecord26[]; - -type CustomRecord27Array CustomRecord27[]; -type CustomRecord28Array CustomRecord28[]; -type CustomRecord29Array CustomRecord29[]; -type CustomRecord30Array CustomRecord30[]; -type CustomRecord31Array CustomRecord31[]; -type CustomRecord32Array CustomRecord32[]; -type CustomRecord33Array CustomRecord33[]; -type CustomRecord34Array CustomRecord34[]; -type CustomRecord35Array CustomRecord35[]; -type CustomRecord36Array CustomRecord36[]; -type CustomRecord37Array CustomRecord37[]; -type CustomRecord38Array CustomRecord38[]; -type CustomRecord39Array CustomRecord39[]; -type CustomRecord40Array CustomRecord40[]; -type CustomRecord41Array CustomRecord41[]; -type CustomRecord42Array CustomRecord42[]; -type CustomRecord43Array CustomRecord43[]; -type CustomRecord44Array CustomRecord44[]; -type CustomRecord45Array CustomRecord45[]; -type CustomRecord46Array CustomRecord46[]; -type CustomRecord47Array CustomRecord47[]; -type CustomRecord48Array CustomRecord48[]; -type CustomRecord49Array CustomRecord49[]; -type CustomRecord50Array CustomRecord50[]; -type CustomRecord51Array CustomRecord51[]; -type CustomRecord52Array CustomRecord52[]; -type CustomRecord53Array CustomRecord53[]; -type CustomRecord54Array CustomRecord54[]; -type CustomRecord55Array CustomRecord55[]; -type CustomRecord56Array CustomRecord56[]; -// type CustomRecord57Array CustomRecord57[]; - -type BooleanTuple1Array BooleanTuple1[]; - -type ClosedBooleanTuple1Array BooleanTuple1[3]; - -type BooleanTuple2Array BooleanTuple2[]; - -type ClosedBooleanTuple2Array BooleanTuple2[3]; - -type BooleanTuple3Array BooleanTuple3[]; - -type ClosedBooleanTuple3Array BooleanTuple3[3]; - -type BooleanTuple4Array BooleanTuple4[]; - -type ClosedBooleanTuple4Array BooleanTuple4[3]; - -type NillableBooleanTuple5Array NillableBooleanTuple5[]; - -type NillableBooleanTuple6Array NillableBooleanTuple6[]; - -type NillableBooleanTuple7Array NillableBooleanTuple7[]; - -type NillableBooleanTuple8Array NillableBooleanTuple8[]; - -type NillableIntBooleanTuple9Array NillableIntBooleanTuple9[]; - -type NilTuple1Array NilTuple1[]; - -type ClosedNilTuple1Array NilTuple1[3]; - -type NilTuple2Array NilTuple2[]; - -type ClosedNilTuple2Array NilTuple2[3]; - -type NilTuple3Array NilTuple3[]; - -type ClosedNilTuple3Array NilTuple3[3]; - -type NilTuple4Array NilTuple4[]; - -type ClosedNilTuple4Array NilTuple4[3]; - -type IntegerTuple1Array IntegerTuple1[]; - -type ClosedIntegerTuple1Array IntegerTuple1[3]; - -type IntegerTuple2Array IntegerTuple2[]; - -type ClosedIntegerTuple2Array IntegerTuple2[3]; - -type IntegerTuple3Array IntegerTuple3[]; - -type ClosedIntegerTuple3Array IntegerTuple3[3]; - -type IntegerTuple4Array IntegerTuple4[]; - -type ClosedIntegerTuple4Array IntegerTuple4[3]; - -type FloatTuple1Array FloatTuple1[]; - -type ClosedFloatTuple1Array FloatTuple1[3]; - -type FloatTuple2Array FloatTuple2[]; - -type ClosedFloatTuple2Array FloatTuple2[3]; - -type FloatTuple3Array FloatTuple3[]; - -type ClosedFloatTuple3Array FloatTuple3[3]; - -type FloatTuple4Array FloatTuple4[]; - -type ClosedFloatTuple4Array FloatTuple4[3]; - -type DecimalTuple1Array DecimalTuple1[]; - -type ClosedDecimalTuple1Array DecimalTuple1[3]; - -type DecimalTuple2Array DecimalTuple2[]; - -type ClosedDecimalTuple2Array DecimalTuple2[3]; - -type DecimalTuple3Array DecimalTuple3[]; - -type ClosedDecimalTuple3Array DecimalTuple3[3]; - -type DecimalTuple4Array DecimalTuple4[]; - -type ClosedDecimalTuple4Array DecimalTuple4[3]; - -type StringTuple1Array StringTuple1[]; - -type ClosedStringTuple1Array StringTuple1[3]; - -type StringTuple2Array StringTuple2[]; - -type ClosedStringTuple2Array StringTuple2[3]; - -type StringTuple3Array StringTuple3[]; - -type ClosedStringTuple3Array StringTuple3[3]; - -type StringTuple4Array StringTuple4[]; - -type ClosedStringTuple4Array StringTuple4[3]; - -type AnydataTuple1Array AnydataTuple1[]; - -type ClosedAnydataTuple1Array AnydataTuple1[3]; - -type AnydataTuple2Array AnydataTuple2[]; - -type ClosedAnydataTuple2Array AnydataTuple2[3]; - -type AnydataTuple3Array AnydataTuple3[]; - -type ClosedAnydataTuple3Array AnydataTuple3[3]; - -type AnydataTuple4Array AnydataTuple4[]; - -type ClosedAnydataTuple4Array AnydataTuple4[3]; - -type JsonTuple1Array JsonTuple1[]; - -type ClosedJsonTuple1Array JsonTuple1[3]; - -type JsonTuple2Array JsonTuple2[]; - -type ClosedJsonTuple2Array JsonTuple2[3]; - -type JsonTuple3Array JsonTuple3[]; - -type ClosedJsonTuple3Array JsonTuple3[3]; - -type JsonTuple4Array JsonTuple4[]; - -type ClosedJsonTuple4Array JsonTuple4[3]; - -type CustomTuple1Array CustomTuple1[]; - -type ClosedCustomTuple1Array CustomTuple1[3]; - -type CustomTuple2Array CustomTuple2[]; - -type ClosedCustomTuple2Array CustomTuple2[3]; - -type CustomTuple3Array CustomTuple3[]; - -type ClosedCustomTuple3Array CustomTuple3[3]; - -type CustomTuple4Array CustomTuple4[]; - -type ClosedCustomTuple4Array CustomTuple4[3]; - -type CustomTuple5Array CustomTuple5[]; - -type ClosedCustomTuple5Array CustomTuple5[3]; - -type CustomTuple6Array CustomTuple6[]; - -type CustomTuple7Array CustomTuple7[]; - -type CustomTuple8Array CustomTuple8[]; - -type ClosedCustomTuple6Array CustomTuple6[3]; - -type IntegerArray1Array IntegerArray1[]; - -type ClosedIntegerArray1Array IntegerArray1[3]; - -type IntegerArray2Array IntegerArray2[]; - -type ClosedIntegerArray2Array IntegerArray2[3]; - -type IntegerArray3Array IntegerArray3[]; - -type ClosedIntegerArray3Array IntegerArray3[3]; - -type IntegerArray4Array IntegerArray4[]; - -type ClosedIntegerArray4Array IntegerArray4[3]; - -type IntegerArray5Array IntegerArray5[]; - -type ClosedIntegerArray5Array IntegerArray5[3]; - -type IntegerArray6Array IntegerArray5[]; - -type ClosedIntegerArray6Array IntegerArray5[3]; - -type StringArray1Array StringArray1[]; - -type StringArrayArray StringArray[]; - -type NillableStringArrayArray NillableStringArray[]; - -type NillableIntOrUnionStringArrayArray NillableIntOrUnionStringArray[]; - -type ClosedStringArray1Array StringArray1[3]; - -type StringArray2Array StringArray2[]; - -type ClosedStringArray2Array StringArray2[3]; - -type StringArray3Array StringArray3[]; - -type ClosedStringArray3Array StringArray3[3]; - -type StringArray4Array StringArray4[]; - -type ClosedStringArray4Array StringArray4[3]; - -type StringArray5Array StringArray5[]; - -type ClosedStringArray5Array StringArray5[3]; - -type StringArray6Array StringArray5[]; - -type ClosedStringArray6Array StringArray5[3]; - -type FloatArray1Array FloatArray1[]; - -type ClosedFloatArray1Array FloatArray1[3]; - -type FloatArray2Array FloatArray2[]; - -type ClosedFloatArray2Array FloatArray2[3]; - -type FloatArray3Array FloatArray3[]; - -type ClosedFloatArray3Array FloatArray3[3]; - -type FloatArray4Array FloatArray4[]; - -type ClosedFloatArray4Array FloatArray4[3]; - -type FloatArray5Array FloatArray5[]; - -type ClosedFloatArray5Array FloatArray5[3]; - -type FloatArray6Array FloatArray5[]; - -type ClosedFloatArray6Array FloatArray5[3]; - -type DecimalArray1Array DecimalArray1[]; - -type ClosedDecimalArray1Array DecimalArray1[3]; - -type DecimalArray2Array DecimalArray2[]; - -type ClosedDecimalArray2Array DecimalArray2[3]; - -type DecimalArray3Array DecimalArray3[]; - -type ClosedDecimalArray3Array DecimalArray3[3]; - -type DecimalArray4Array DecimalArray4[]; - -type ClosedDecimalArray4Array DecimalArray4[3]; - -type DecimalArray5Array DecimalArray5[]; - -type ClosedDecimalArray5Array DecimalArray5[3]; - -type DecimalArray6Array DecimalArray5[]; - -type ClosedDecimalArray6Array DecimalArray5[3]; - -type BooleanArrayArray BooleanArray[]; - -type ClosedBooleanArrayArray BooleanArray[3]; - -type NillableBooleanArrayArray NillableBooleanArray[]; - -type NillableIntOrUnionBooleanArrayArray NillableIntOrUnionBooleanArray[]; - -type BooleanArray2Array BooleanArray2[]; - -type ClosedBooleanArray2Array BooleanArray2[3]; - -type BooleanArray3Array BooleanArray3[]; - -type ClosedBooleanArray3Array BooleanArray3[3]; - -type BooleanArray4Array BooleanArray4[]; - -type ClosedBooleanArray4Array BooleanArray4[3]; - -type BooleanArray5Array BooleanArray5[]; - -type ClosedBooleanArray5Array BooleanArray5[3]; - -type BooleanArray6Array BooleanArray5[]; - -type ClosedBooleanArray6Array BooleanArray5[3]; - -type NilArray1Array NilArray1[]; - -type ClosedNilArray1Array NilArray1[3]; - -type NilArray2Array NilArray2[]; - -type ClosedNilArray2Array NilArray2[3]; - -type NilArray3Array NilArray3[]; - -type ClosedNilArray3Array NilArray3[3]; - -type NilArray4Array NilArray4[]; - -type ClosedNilArray4Array NilArray4[3]; - -type NilArray5Array NilArray5[]; - -type ClosedNilArray5Array NilArray5[3]; - -type NilArray6Array NilArray5[]; - -type ClosedNilArray6Array NilArray5[3]; - -type JsonArray1Array JsonArray1[]; - -type ClosedJsonArray1Array JsonArray1[3]; - -type JsonArray2Array JsonArray2[]; - -type ClosedJsonArray2Array JsonArray2[3]; - -type JsonArray3Array JsonArray3[]; - -type ClosedJsonArray3Array JsonArray3[3]; - -type JsonArray4Array JsonArray4[]; - -type ClosedJsonArray4Array JsonArray4[3]; - -type JsonArray5Array JsonArray5[]; - -type ClosedJsonArray5Array JsonArray5[3]; - -type JsonArray6Array JsonArray5[]; - -type ClosedJsonArray6Array JsonArray5[3]; - -type AnydataArray1Array AnydataArray1[]; - -type ClosedAnydataArray1Array AnydataArray1[3]; - -type AnydataArray2Array AnydataArray2[]; - -type ClosedAnydataArray2Array AnydataArray2[3]; - -type AnydataArray3Array AnydataArray3[]; - -type ClosedAnydataArray3Array AnydataArray3[3]; - -type AnydataArray4Array AnydataArray4[]; - -type ClosedAnydataArray4Array AnydataArray4[3]; - -type AnydataArray5Array AnydataArray5[]; - -type ClosedAnydataArray5Array AnydataArray5[3]; - -type AnydataArray6Array AnydataArray5[]; - -type ClosedAnydataArray6Array AnydataArray5[3]; - -type CustomArray1Array CustomArray1[]; - -type ClosedCustomArray1Array CustomArray1[3]; - -type CustomArray2Array CustomArray2[]; - -type ClosedCustomArray2Array CustomArray2[3]; - -type CustomArray3Array CustomArray3[]; - -type ClosedCustomArray3Array CustomArray3[3]; - -type CustomArray4Array CustomArray4[]; - -type ClosedCustomArray4Array CustomArray4[3]; - -type CustomArray5Array CustomArray5[]; - -type ClosedCustomArray5Array CustomArray5[3]; - -type CustomArray6Array CustomArray5[]; - -type ClosedCustomArray6Array CustomArray5[3]; - -type IntegerMapArray IntegerMap[]; - -type ClosedIntegerMapArray IntegerMap[3]; - -type StringMapArray StringMap[]; - -type NillableIntUnionStringMapArray NillableIntUnionStringMap[]; - -type IntUnionStringMapArray IntUnionStringMap[]; - -type ClosedStringMapArray StringMap[3]; - -type DecimalMapArray DecimalMap[]; - -type ClosedDecimalMapArray DecimalMap[3]; - -type FloatMapArray FloatMap[]; - -type ClosedFloatMapArray FloatMap[3]; - -type BooleanMapArray BooleanMap[]; - -type NillableBooleanMapArray NillableBooleanMap[]; - -type NillableIntUnionBooleanMapArray NillableIntUnionBooleanMap[]; - -type IntUnionBooleanMapArray IntUnionBooleanMap[]; - -type ClosedBooleanMapArray BooleanMap[3]; - -type NilMapArray NilMap[]; - -type ClosedNilMapArray NilMap[3]; - -type JsonMapArray JsonMap[]; - -type ClosedJsonMapArray JsonMap[3]; - -type AnydataMapArray AnydataMap[]; - -type ClosedAnydataMapArray AnydataMap[3]; - -type CustomMapArray CustomMap[]; - -type ClosedCustomMapArray CustomMap[3]; - -type RecordWithCustomAnnotation record { - @Name { - value: "c" - } - int a; - int b; -}; - -type RecordWithCustomAnnotation2 record { - @Name { - value: "c" - } - int a?; - @Name { - value: "d" - } - int? b; -}; - -type RecordWithCustomAnnotation3 record {| - @Name { - value: "c" - } - int a?; - @Name { - value: "d" - } - int? b; -|}; - -type RecordWithCustomAnnotation4 record {| - @Name { - value: "c" - } - int a; - @Name { - value: "d" - } - int b; - boolean...; -|}; - -type RecordWithCustomAnnotation5 record { - @Name { - value: "c" - } - int a; - @Name { - value: "d" - } - int b; - int c?; -}; - -type RecordWithCustomAnnotation6 record { - @Name { - value: "c" - } - int a; - @Name { - value: "d" - } - int b; - @Name { - value: "e" - } - int c; -}; - -type RecordWithCustomAnnotation7 record { - @Name { - value: "c" - } - int a; - @Name { - value: "d" - } - int b; - @Name { - value: "a" - } - int c; -}; - -type RecordWithCustomAnnotation8 record { - @Name { - value: "c" - } - int a; - @Name { - value: "c" - } - int b; - @Name { - value: "a" - } - int c; -}; From 251fd73195abc18e5462b4436b6c0aa1ad60f20c Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 13:21:03 +0530 Subject: [PATCH 7/9] Add github workflows --- .github/CODEOWNERS | 7 ++++ .github/pull_request_template.md | 12 ++++++ .../workflows/build-timestamped-master.yml | 18 +++++++++ .../workflows/build-with-bal-test-graalvm.yml | 37 +++++++++++++++++++ .github/workflows/central-publish.yml | 21 +++++++++++ .github/workflows/publish-release.yml | 16 ++++++++ .github/workflows/pull-request.yml | 14 +++++++ .github/workflows/stale-check.yml | 19 ++++++++++ .github/workflows/trivy-scan.yml | 13 +++++++ 9 files changed, 157 insertions(+) create mode 100644 .github/CODEOWNERS create mode 100644 .github/pull_request_template.md create mode 100644 .github/workflows/build-timestamped-master.yml create mode 100644 .github/workflows/build-with-bal-test-graalvm.yml create mode 100644 .github/workflows/central-publish.yml create mode 100644 .github/workflows/publish-release.yml create mode 100644 .github/workflows/pull-request.yml create mode 100644 .github/workflows/stale-check.yml create mode 100644 .github/workflows/trivy-scan.yml diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..d0878e0 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,7 @@ +# Lines starting with '#' are comments. +# Each line is a file pattern followed by one or more owners. + +# See: https://help.github.com/articles/about-codeowners/ + +# These owners will be the default owners for everything in the repo. +* @hasithaa @SasinduDilshara diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..96b073c --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,12 @@ +## Purpose + +Fixes: + +## Examples + +## Checklist +- [ ] Linked to an issue +- [ ] Updated the changelog +- [ ] Added tests +- [ ] Updated the spec +- [ ] Checked native-image compatibility diff --git a/.github/workflows/build-timestamped-master.yml b/.github/workflows/build-timestamped-master.yml new file mode 100644 index 0000000..72d594a --- /dev/null +++ b/.github/workflows/build-timestamped-master.yml @@ -0,0 +1,18 @@ +name: Build + +on: + push: + branches: + - main + paths-ignore: + - '*.md' + - 'docs/**' + - 'load-tests/**' + workflow_dispatch: + +jobs: + call_workflow: + name: Run Build Workflow + if: ${{ github.repository_owner == 'ballerina-platform' }} + uses: ballerina-platform/ballerina-library/.github/workflows/build-timestamp-master-template.yml@main + secrets: inherit diff --git a/.github/workflows/build-with-bal-test-graalvm.yml b/.github/workflows/build-with-bal-test-graalvm.yml new file mode 100644 index 0000000..291054d --- /dev/null +++ b/.github/workflows/build-with-bal-test-graalvm.yml @@ -0,0 +1,37 @@ +name: GraalVM Check + +on: + workflow_dispatch: + inputs: + lang_tag: + description: Branch/Release Tag of the Ballerina Lang + required: true + default: master + lang_version: + description: Ballerina Lang Version (If given ballerina lang build will be skipped) + required: false + default: '' + native_image_options: + description: Default native-image options + required: false + default: '' + schedule: + - cron: '30 18 * * *' + pull_request: + branches: + - main + types: [ opened, synchronize, reopened, labeled, unlabeled ] + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +jobs: + call_stdlib_workflow: + name: Run StdLib Workflow + if: ${{ github.event_name != 'schedule' || (github.event_name == 'schedule' && github.repository_owner == 'ballerina-platform') }} + uses: ballerina-platform/ballerina-library/.github/workflows/build-with-bal-test-graalvm-template.yml@main + with: + lang_tag: ${{ inputs.lang_tag }} + lang_version: ${{ inputs.lang_version }} + native_image_options: '-J-Xmx7G ${{ inputs.native_image_options }}' diff --git a/.github/workflows/central-publish.yml b/.github/workflows/central-publish.yml new file mode 100644 index 0000000..11922b5 --- /dev/null +++ b/.github/workflows/central-publish.yml @@ -0,0 +1,21 @@ +name: Publish to the Ballerina central + +on: + workflow_dispatch: + inputs: + environment: + type: choice + description: Select Environment + required: true + options: + - DEV CENTRAL + - STAGE CENTRAL + +jobs: + call_workflow: + name: Run Central Publish Workflow + if: ${{ github.repository_owner == 'ballerina-platform' }} + uses: ballerina-platform/ballerina-library/.github/workflows/central-publish-template.yml@main + secrets: inherit + with: + environment: ${{ github.event.inputs.environment }} diff --git a/.github/workflows/publish-release.yml b/.github/workflows/publish-release.yml new file mode 100644 index 0000000..9454d4e --- /dev/null +++ b/.github/workflows/publish-release.yml @@ -0,0 +1,16 @@ +name: Publish Release + +on: + workflow_dispatch: + repository_dispatch: + types: [stdlib-release-pipeline] + +jobs: + call_workflow: + name: Run Release Workflow + if: ${{ github.repository_owner == 'ballerina-platform' }} + uses: ballerina-platform/ballerina-library/.github/workflows/release-package-template.yml@main + secrets: inherit + with: + package-name: data.jsondata + package-org: ballerina diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml new file mode 100644 index 0000000..06f4f56 --- /dev/null +++ b/.github/workflows/pull-request.yml @@ -0,0 +1,14 @@ +name: Pull Request + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +on: pull_request + +jobs: + call_workflow: + name: Run PR Build Workflow + if: ${{ github.repository_owner == 'ballerina-platform' }} + uses: ballerina-platform/ballerina-library/.github/workflows/pull-request-build-template.yml@main + secrets: inherit diff --git a/.github/workflows/stale-check.yml b/.github/workflows/stale-check.yml new file mode 100644 index 0000000..8763360 --- /dev/null +++ b/.github/workflows/stale-check.yml @@ -0,0 +1,19 @@ +name: 'Close stale pull requests' + +on: + schedule: + - cron: '30 19 * * *' + workflow_dispatch: + +jobs: + stale: + runs-on: ubuntu-latest + steps: + - uses: actions/stale@v3 + with: + stale-pr-message: 'This PR has been open for more than 15 days with no activity. This will be closed in 3 days unless the `stale` label is removed or commented.' + close-pr-message: 'Closed PR due to inactivity for more than 18 days.' + days-before-pr-stale: 15 + days-before-pr-close: 3 + days-before-issue-stale: -1 + days-before-issue-close: -1 diff --git a/.github/workflows/trivy-scan.yml b/.github/workflows/trivy-scan.yml new file mode 100644 index 0000000..2f7999d --- /dev/null +++ b/.github/workflows/trivy-scan.yml @@ -0,0 +1,13 @@ +name: Trivy + +on: + workflow_dispatch: + schedule: + - cron: '30 20 * * *' + +jobs: + call_workflow: + name: Run Trivy Scan Workflow + if: ${{ github.repository_owner == 'ballerina-platform' }} + uses: ballerina-platform/ballerina-library/.github/workflows/trivy-scan-template.yml@main + secrets: inherit From e495136c181c473bade79ad594fda9a70276a60e Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 13:41:11 +0530 Subject: [PATCH 8/9] [Automated] Update the native jar versions --- ballerina/Ballerina.toml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/ballerina/Ballerina.toml b/ballerina/Ballerina.toml index c51f02f..ecae9dc 100644 --- a/ballerina/Ballerina.toml +++ b/ballerina/Ballerina.toml @@ -17,9 +17,3 @@ groupId = "io.ballerina.stdlib" artifactId = "data.csv-native" version = "0.1.0" path = "../native/build/libs/data.csv-native-0.1.0-SNAPSHOT.jar" - -[[platform.java17.dependency]] -groupId = "io.ballerina.stdlib" -artifactId = "constraint-native" -version = "@constraint.version@" -path = "./lib/constraint-native-@stdlib.constraintnative.version@.jar" From b4339ef4f3ad07cc818d8321c006df822f64b4ac Mon Sep 17 00:00:00 2001 From: Sasindu Alahakoon Date: Thu, 4 Jul 2024 13:51:25 +0530 Subject: [PATCH 9/9] Add codecov.yml file --- .gitattributes | 2 ++ ballerina/csv_api.bal | 18 ++++++++++-------- build-config/resources/Ballerina.toml | 6 ------ codecov.yml | 8 ++++++++ 4 files changed, 20 insertions(+), 14 deletions(-) create mode 100644 .gitattributes create mode 100644 codecov.yml diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..d13affe --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Ensure all Java files use LF. +*.java eol=lf diff --git a/ballerina/csv_api.bal b/ballerina/csv_api.bal index db3fd88..7355b09 100644 --- a/ballerina/csv_api.bal +++ b/ballerina/csv_api.bal @@ -72,9 +72,9 @@ public isolated function parseStreamToList(stream s, ParseOption options = {}, typedesc t = <>) returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; -# Convert value of type `record{}[]` to subtype of `record{}[]`. +# Convert value of type record{}[] to subtype of record{}[]. # -# + v - Source Ballerina record array value +# + s - Source Ballerina record array value # + options - Options to be used for filtering in the projection # + t - Target type # + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. @@ -82,9 +82,10 @@ public isolated function parseRecordAsRecordType(record{}[] s, RecordAsRecordOption options = {}, typedesc t = <>) returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; -# Convert value of type `record{}[]` to subtype of `anydata[][]`. +# Convert value of type record{}[] to subtype of anydata[][]. # -# + v - Source Ballerina record array value +# + s - Source Ballerina record array value +# + headerNames - The order of the header names in the source # + options - Options to be used for filtering in the projection # + t - Target type # + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. @@ -92,9 +93,10 @@ public isolated function parseRecordAsListType(record{}[] s, string[] headerName Options options = {}, typedesc t = <>) returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; -# Convert value of type `string[][]` to subtype of `record{}[]`. +# Convert value of type string[][] to subtype of record{}[]. # -# + v - Source Ballerina string array of array value +# + s - Source Ballerina string array of array value +# + customHeaders - The order of the header names in the source # + options - Options to be used for filtering in the projection # + t - Target type # + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. @@ -102,9 +104,9 @@ public isolated function parseListAsRecordType(string[][] s, string[]? customHea ListAsRecordOption options = {}, typedesc t = <>) returns t|Error = @java:Method {'class: "io.ballerina.stdlib.data.csvdata.csv.Native"} external; -# Convert value of type `string[][]` to subtype of `anydata[][]`. +# Convert value of type string[][] to subtype of anydata[][]. # -# + v - Source Ballerina string array of array value +# + s - Source Ballerina string array of array value # + options - Options to be used for filtering in the projection # + t - Target type # + return - On success, returns value belonging to the given target type, else returns an `csv:Error` value. diff --git a/build-config/resources/Ballerina.toml b/build-config/resources/Ballerina.toml index ea02379..3db6b47 100644 --- a/build-config/resources/Ballerina.toml +++ b/build-config/resources/Ballerina.toml @@ -17,9 +17,3 @@ groupId = "io.ballerina.stdlib" artifactId = "data.csv-native" version = "@toml.version@" path = "../native/build/libs/data.csv-native-@project.version@.jar" - -[[platform.java17.dependency]] -groupId = "io.ballerina.stdlib" -artifactId = "constraint-native" -version = "@constraint.version@" -path = "./lib/constraint-native-@stdlib.constraintnative.version@.jar" diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000..f60b970 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,8 @@ +coverage: + precision: 2 + round: down + range: "60...80" + status: + project: + default: + target: 80