Merge pull request #22 from Anshukumar123975/main

feat(rust): Add AST files for the CTO files and support for concerto-rust

Author: ekarademir

CONTRIBUTION.md

@@ -0,0 +1,13 @@
+# Concerto Conformance Contribution Guide      
+## 1. To add new semantic rules:    
+a. Add the model file (.cto) within the specification folder under the suitable specification type.     
+b. Add the scenario in the {specification_type}.feature file using the steps statement mentioned in the steps file.    
+c. Run the script `npm run convert-ast file_path`    
+d. If the cto file is syntactically valid a .json file will be created after running the above script just in the same directory as the corresponding .cto file.    
+e. If the cto file is syntactically invalid then no .json file will be created and the steps file will consider it as an invalid model.
+
+## 2. To modify the semantic rules:    
+a. To change the scenario you must change the scenario according to the statements in the steps file.    
+b. If creating a new step then ensure it's working correctly!   
+
+#### We'd love for you to contribute to our source code and to make Concerto Conformance Test Suite more robust and accurate!

convertToAST.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { Parser } from '@accordproject/concerto-cto';
+
+const BASE_DIR = path.resolve('semantic/specifications');
+
+function getAllCTOFiles(dir) {
+  let files = [];
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files = files.concat(getAllCTOFiles(fullPath));
+    } else if (entry.isFile() && fullPath.endsWith('.cto')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function convertAndWriteAST(ctoPath) {
+  try {
+    const modelContent = fs.readFileSync(ctoPath, 'utf8');
+    const ast = Parser.parse(modelContent, ctoPath);
+
+    const outFileName = path.basename(ctoPath).replace('.cto', '.json');
+    const outDir = path.dirname(ctoPath); // same directory as .cto
+    const outFilePath = path.join(outDir, outFileName);
+
+    fs.writeFileSync(outFilePath, JSON.stringify(ast, null, 2), 'utf8');
+    console.log(`✅ Converted: ${ctoPath} → ${outFilePath}`);
+  } catch (error) {
+    console.error(`❌ Failed to convert: ${ctoPath}`);
+    console.error(error.message);
+  }
+}
+
+function run() {
+  const allCTOs = getAllCTOFiles(BASE_DIR);
+  allCTOs.forEach(convertAndWriteAST);
+}
+
+run();

convertToASTpath.js

@@ -0,0 +1,30 @@
+// parseCtoToAst.js
+import fs from 'fs';
+import path from 'path';
+import { Parser } from '@accordproject/concerto-cto';
+
+function convertCTOToAST(ctoPath) {
+  try {
+    const absolutePath = path.resolve(ctoPath);
+    const dir = path.dirname(absolutePath);
+    const baseName = path.basename(absolutePath, '.cto');
+    const outFilePath = path.join(dir, `${baseName}.json`);
+
+    const modelContent = fs.readFileSync(absolutePath, 'utf8');
+    const ast = Parser.parse(modelContent, absolutePath);
+
+    fs.writeFileSync(outFilePath, JSON.stringify(ast, null, 2), 'utf8');
+    console.log(`✅ AST written to: ${outFilePath}`);
+  } catch (err) {
+    console.error(`❌ Failed to parse: ${ctoPath}`);
+    console.error(`Error: ${err.message}`);
+  }
+}
+
+const inputPath = process.argv[2];
+if (!inputPath) {
+  console.error('❗ Usage: node parseCtoToAst.js <path/to/file.cto>');
+  process.exit(1);
+}
+
+convertCTOToAST(inputPath);

package.json

@@ -9,7 +9,8 @@
     "test:semantic": "cucumber-js \"semantic/features/**/*.feature\" --loader ts-node/esm --import \"semantic/features/support/Javascript/*.ts\" --tags \"not @skip\"",
     "test:instances": "cucumber-js validate/features --import validate/validateSteps.js",
     "test:csharp": "dotnet test semantic/features/support/C#/Semantic.Support.CSharp/Semantic.Support.CSharp.csproj",
-    "start": "node cli.js"
+    "start": "node cli.js",
+    "convert-ast": "node convertToASTpath.js"
   },
   "keywords": [],
   "author": "",

semantic/features/concepts.feature

@@ -3,43 +3,43 @@ Feature: Semantic Validation of Enum Declarations in CTO Models
   Scenario: Duplicate enum names in the same file should throw an error
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/DECLARATION_001/declaration_001_duplicate_enum_names.cto | main       |
+      | enums/models/DECLARATION_001/declaration_001_duplicate_enum_names.json | main       |
     When I validate the models
     Then an error should be thrown with message "Duplicate"
 
   Scenario: Unique enum names in the same file should pass validation
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/DECLARATION_001/declaration_001_unique_enum_names.cto    | main       |
+      | enums/models/DECLARATION_001/declaration_001_unique_enum_names.json    | main       |
     When I validate the models
     Then no error should be thrown
 
   Scenario: Local enum name does not conflict with imported enum
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/DECLARATION_002/importedTypes.cto                      | imported   |
-      | enums/models/DECLARATION_002/declaration_002_non_conflicting_name.cto | main     |
+      | enums/models/DECLARATION_002/importedTypes.json                      | imported   |
+      | enums/models/DECLARATION_002/declaration_002_non_conflicting_name.json | main     |
     When I validate the models
     Then no error should be thrown
 
   @skip
   Scenario: Enum name conflicts with imported enum should throw an error
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/DECLARATION_002/importedTypes.cto                      | imported   |
-      | enums/models/DECLARATION_002/declaration_002_name_conflict_with_import.cto | main |
+      | enums/models/DECLARATION_002/importedTypes.json                      | imported   |
+      | enums/models/DECLARATION_002/declaration_002_name_conflict_with_import.json | main |
     When I validate the models
     Then an error should be thrown with message "already defined in an imported model"
 
   Scenario: Valid enum identifier name should pass validation
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/MODEL_ELEMENT_002/model_element_002_valid_enum_name.cto  | main       |
+      | enums/models/MODEL_ELEMENT_002/model_element_002_valid_enum_name.json  | main       |
     When I validate the models
     Then no error should be thrown
 
   Scenario: Invalid enum identifier name should throw an error
     Given I load the following models:
       | model_file                                                   | alias      |
-      | enums/models/MODEL_ELEMENT_002/model_element_002_invalid_enum_name.cto | main     |
+      | enums/models/MODEL_ELEMENT_002/model_element_002_invalid_enum_name.json | main     |
     Then an error should be thrown with message ""

semantic/features/enums.feature

@@ -3,49 +3,49 @@ Feature: Semantic Validation of CTO Model Imports
   Scenario: Local and imported types have unique names and should pass validation
     Given I load the following models:
       | model_file                                                               | alias      |
-      | imports/models/DECLARATION_002/importedTypes.cto                         | imported   |
-      | imports/models/DECLARATION_002/declaration_002_unique_with_imported_type.cto | main   |
+      | imports/models/DECLARATION_002/importedTypes.json                         | imported   |
+      | imports/models/DECLARATION_002/declaration_002_unique_with_imported_type.json | main   |
     When I validate the models
     Then no error should be thrown
 
   @skip
   Scenario: Conflict with imported type name should throw an error
     Given I load the following models:
       | model_file                                                               | alias      |
-      | imports/models/DECLARATION_002/importedTypes.cto                         | imported   |
-      | imports/models/DECLARATION_002/declaration_002_conflict_with_imported_type.cto | main |
+      | imports/models/DECLARATION_002/importedTypes.json                         | imported   |
+      | imports/models/DECLARATION_002/declaration_002_conflict_with_imported_type.json | main |
     When I validate the models
     Then an error should be thrown with message "already defined in an imported model"
 
   Scenario: Valid import and reference of existing type should pass validation
     Given I load the following models:
       | model_file                                                               | alias      |
-      | imports/models/DECLARATION_002/importedTypes.cto                         | imported   |
-      | imports/models/MODEL_FILE_001/model_file_001_existing_import_type.cto    | main       |
+      | imports/models/DECLARATION_002/importedTypes.json                         | imported   |
+      | imports/models/MODEL_FILE_001/model_file_001_existing_import_type.json    | main       |
     When I validate the models
     Then no error should be thrown
 
   Scenario: Importing a non-existent type should throw an error
     Given I load the following models:
       | model_file                                                                       | alias  |
-      | imports/models/MODEL_FILE_001/model_file_001_import_nonexistent_type.cto         | main   |
+      | imports/models/MODEL_FILE_001/model_file_001_import_nonexistent_type.json         | main   |
     When I validate the models
     Then an error should be thrown with message "Namespace is not defined"
 
   Scenario: Unique namespace imports should pass validation
     Given I load the following models:
       | model_file                                                               | alias    |
-      | imports/models/DECLARATION_002/importedTypes.cto                         | import1  |
-      | imports/models/DECLARATION_002/importedTypes2.cto                        | import2  |
-      | imports/models/MODEL_FILE_002/model_file_002_unique_namespace_imports.cto | main     |
+      | imports/models/DECLARATION_002/importedTypes.json                         | import1  |
+      | imports/models/DECLARATION_002/importedTypes2.json                        | import2  |
+      | imports/models/MODEL_FILE_002/model_file_002_unique_namespace_imports.json | main     |
     When I validate the models
     Then no error should be thrown
 
   @skip
   Scenario: Duplicate namespace imports should throw an error
     Given I load the following models:
       | model_file                                                               | alias    |
-      | imports/models/DECLARATION_002/importedTypes.cto                         | import1  |
-      | imports/models/MODEL_FILE_002/model_file_002_duplicate_namespace_imports.cto | main |
+      | imports/models/DECLARATION_002/importedTypes.json                         | import1  |
+      | imports/models/MODEL_FILE_002/model_file_002_duplicate_namespace_imports.json | main |
     When I validate the models
     Then an error should be thrown with message "Import from namespace .* already exists"

semantic/features/imports.feature

@@ -3,40 +3,40 @@ Feature: Semantic Validation of CTO Map Specification
   Scenario: Valid map key type should pass
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/MAP_KEY_TYPE_001/map_key_type_001_valid_key_type.cto             | main  |
+      | maps/models/MAP_KEY_TYPE_001/map_key_type_001_valid_key_type.json             | main  |
     When I validate the models
     Then no error should be thrown
 
   Scenario: Invalid map key type should throw error
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/MAP_KEY_TYPE_001/map_key_type_001_invalid_key_type.cto           | main  |
-    Then an error should be thrown with message "Expected \"DateTime\", \"String\""
+      | maps/models/MAP_KEY_TYPE_001/map_key_type_001_invalid_key_type.json           | main  |
+    Then an error should be thrown with message ""
 
   Scenario: Valid map value type should pass
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/MAP_VALUE_TYPE_001/map_value_type_001_existing_value_type.cto      | main  |
+      | maps/models/MAP_VALUE_TYPE_001/map_value_type_001_existing_value_type.json      | main  |
     When I validate the models
     Then no error should be thrown
 
   Scenario: Non-existent map value type should throw error
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/MAP_VALUE_TYPE_001/map_value_type_001_type_not_exist.cto           | main  |
+      | maps/models/MAP_VALUE_TYPE_001/map_value_type_001_type_not_exist.json           | main  |
     When I validate the models
     Then an error should be thrown with message "Cannot read properties of null"
 
   Scenario: Duplicate map names should throw error
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/DECLARATION_001/declaration_001_duplicate_map_name.cto          | main  |
+      | maps/models/DECLARATION_001/declaration_001_duplicate_map_name.json          | main  |
     When I validate the models
     Then an error should be thrown with message "Duplicate class name"
 
   Scenario: Unique map names should pass
     Given I load the following models:
       | model_file                                      | alias |
-      | maps/models/DECLARATION_001/declaration_001_unique_map_name.cto             | main  |
+      | maps/models/DECLARATION_001/declaration_001_unique_map_name.json             | main  |
     When I validate the models
     Then no error should be thrown

semantic/features/maps.feature

@@ -4,29 +4,47 @@ Feature: Semantic Validation of CTO Namespace Imports
   Scenario: Invalid duplicate namespace imports should throw an error
     Given I load the following models:
       | model_file                                               | alias    |
-      | namespaces/models/MODEL_FILE_002/importedTypes.cto       | imported |
-      | namespaces/models/MODEL_FILE_002/model_file_002_duplicate_namespace_imports.cto | main |
+      | namespaces/models/MODEL_FILE_002/importedTypes.json       | imported |
+      | namespaces/models/MODEL_FILE_002/model_file_002_duplicate_namespace_imports.json | main |
     When I validate the models
-    Then an error should be thrown with message "Namespace org.external.types is already defined"
+    Then an error should be thrown with message "Import namespace is already defined"
 
   Scenario: Valid unique namespace imports should pass
     Given I load the following models:
       | model_file                                               | alias    |
-      | namespaces/models/MODEL_FILE_002/importedTypes.cto       | imported |
-      | namespaces/models/MODEL_FILE_002/model_file_002_unique_namespace_imports.cto | main |
+      | namespaces/models/MODEL_FILE_002/importedTypes.json       | imported |
+      | namespaces/models/MODEL_FILE_002/model_file_002_unique_namespace_imports.json | main |
     When I validate the models
     Then no error should be thrown
 
-  Scenario: Invalid self-import should throw MODEL_FILE_004 error
+  Scenario: Invalid self-import should throw MODEL_FILE_003 error
     Given I load the following models:
       | model_file                                               | alias    |
-      | namespaces/models/MODEL_FILE_003/model_file_003_self_import.cto | main |
+      | namespaces/models/MODEL_FILE_003/model_file_003_self_import.json | main |
     When I validate the models
     Then an error should be thrown with message "Namespace is not defined for type"
 
   Scenario: Valid model without self-import should pass
     Given I load the following models:
       | model_file                                               | alias    |
-      | namespaces/models/MODEL_FILE_003/model_file_003_valid_import.cto | main |
+      | namespaces/models/MODEL_FILE_003/model_file_003_valid_import.json | main |
+    When I validate the models
+    Then no error should be thrown
+
+  @skip
+  Scenario: Invalid duplicate declared names from different namespace imports should throw an error
+    Given I load the following models:
+      | model_file                                               | alias    |
+      | namespaces/models/MODEL_FILE_004/importedTypes.json       | imported |
+      | namespaces/models/MODEL_FILE_004/importedTypestwo.json       | imported |
+      | namespaces/models/MODEL_FILE_004/model_file_004_duplicate_namespace_imports.json | main |
+    When I validate the models
+    Then an error should be thrown with message "Can't import same names for different namespaces"
+
+  Scenario: Valid unique namespace imports should pass
+    Given I load the following models:
+      | model_file                                               | alias    |
+      | namespaces/models/MODEL_FILE_004/importedTypes.json       | imported |
+      | namespaces/models/MODEL_FILE_004/model_file_004_unique_namespace_imports.json | main |
     When I validate the models
     Then no error should be thrown