codeplain 0.2.13__tar.gz → 0.2.14__tar.gz

{codeplain-0.2.13 → codeplain-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.2.13
+Version: 0.2.14
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

codeplain-0.2.14/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.14"

{codeplain-0.2.13 → codeplain-0.2.14}/docs/starting_a_plain_project_from_scratch.md

@@ -21,35 +21,40 @@ my-new-project/
 ├── config.yaml                         # CLI configuration
 ├── run_unittests_[language].sh         # Unit test script
 ├── run_conformance_tests_[language].sh # Conformance test script
-├── build/                              # Generated
-└── conformance_tests/                  # Generated
+├── build/                              # Generated final code
+├── plain_modules/                      # Generated modules code
+└── conformance_tests/                  # Generated conformanece tests code
 ```
 
 In this guide we will cover how to create each of these step by step.
 
 ## 1. Define Your .plain File
 
-Create a `.plain` file. The following example shows how to specify the array sorting problem. For more details, see [***plain language specifications](https://www.plainlang.org/docs/intro/).
+Create a `.plain` file. The following example shows how to specify the array sorting problem. For more details, see [***plain language specifications](https://www.plainlang.org/docs/).
 
 **Example: `array_sorting.plain`**
 ```plain
-{% include "python-console-app-template.plain", main_executable_file_name: "array_sorting.py" %}
+---
+description: 'Example showing how to specify the array sorting problem'
+import:
+  - python-console-app-template
+---
 
-***Definitions:***
-- The Array is an array of integers received as input.
+***definitions***
+- :Array: is an array of integers received as input.
 
-***Functional Requirements:***
-- The App should be extended to receive The Array
-- Sort The Array.
-- Display The Array.
+***functional specs***
+- :App: should be extended to receive :Array:
+- Sort :Array:
+- Display :Array:
 
-    ***Acceptance Tests:***
-    - When given input "5 2 8 1 9", The App should output "1 2 5 8 9"
-    - When given input "1 2 3 4 5", The App should output "1 2 3 4 5"
+    ***acceptance tests***
+    - When given input "5 2 8 1 9", :App: should output "1 2 5 8 9"
+    - When given input "1 2 3 4 5", :App: should output "1 2 3 4 5"
 
 ```
 
-- When including templates, use `--full-plain` flag to preview the complete specification including all template content before rendering. You can find predefined templates in [standard template library](../standard_template_library/). (This flag can be configured in your config file.)
+`python-console-app-template` is predefined template providing specification of a typical Python console application. Check [standard template library](../standard_template_library/) for available predefined templates.
 
 ## 2. Add Test Scripts
 
@@ -59,7 +64,7 @@ Include the appropriate test scripts to your project:
 cp /path/to/plain2code_client/test_scripts/run_unittests_python.sh ./
 cp /path/to/plain2code_client/test_scripts/run_conformance_tests_python.sh ./
 ```
-- You may need to modify these scripts based on your specific project requirements.
+You may need to modify these scripts based on your specific project requirements.
 
 ## 3. Configure Parameters
 
@@ -71,6 +76,8 @@ Example of a basic `config.yaml` file:
 
 unittests-script: ./run_unittests_python.sh
 conformance-tests-script: ./run_conformance_tests_python.sh
+copy-build: true
+build-dest: build
 verbose: true
 
 ```
@@ -81,14 +88,7 @@ verbose: true
 ## 4. Generate & Run Your Project
 
 ```bash
-python ../plain2code_client/plain2code.py my_app.plain
+codeplain my_app.plain
 ```
-- Generated code will appear in build/ and conformance_tests/.
 
-
-## 5. Notes
-- `build/` and `conformance_tests/` folders are generated automatically
-- These folders are excluded from git via `.gitignore`
-- `dist/` and `dist_conformance_tests/` are created if you set `copy-build: true` and `copy-conformance-tests: true` in your config.yaml
-- Always review generated code before using in production
-- The `.plain` file is your source of truth - keep it well-documented and version-controlled
+After rendering is completed the generated code will be available in build/ folder.

{codeplain-0.2.13 → codeplain-0.2.14}/memory_management.py

@@ -14,11 +14,11 @@ CONFORMANCE_TEST_MEMORY_SUBFOLDER = "conformance_test_memory"
 class MemoryManager:
 
     @staticmethod
-    def fetch_memory_files(memory_folder: str):
+    def fetch_memory_files(memory_folder: str) -> tuple[list[str], dict[str, str]]:
         """Fetch memory files from memory_folder/conformance_test_memory."""
         memory_path = os.path.join(memory_folder, CONFORMANCE_TEST_MEMORY_SUBFOLDER)
         if not os.path.exists(memory_path):
-            return {}, {}
+            return [], {}
         memory_files = file_utils.list_all_text_files(memory_path)
         memory_files_content = file_utils.get_existing_files_content(memory_path, memory_files)
         console.info(f"Loaded {len(memory_files_content)} memory files.")

{codeplain-0.2.13 → codeplain-0.2.14}/plain2code.py

@@ -51,17 +51,6 @@ from tui.plain2code_tui import Plain2CodeTUI
 
 DEFAULT_TEMPLATE_DIRS = importlib.resources.files("standard_template_library")
 
-MAX_UNITTEST_FIX_ATTEMPTS = 20
-MAX_CONFORMANCE_TEST_FIX_ATTEMPTS = 20
-MAX_CONFORMANCE_TEST_RUNS = 20
-MAX_REFACTORING_ITERATIONS = 5
-MAX_UNIT_TEST_RENDER_RETRIES = 2
-
-MAX_ISSUE_LENGTH = 10000  # Characters.
-
-UNRECOVERABLE_ERROR_EXIT_CODES = [69]
-TIMEOUT_ERROR_EXIT_CODE = 124
-
 
 def get_render_range(render_range, plain_source):
     render_range = render_range.split(",")

{codeplain-0.2.13 → codeplain-0.2.14}/plain2code_arguments.py

@@ -2,6 +2,8 @@ import argparse
 import os
 import re
 
+from plain2code_console import console
+from plain2code_exceptions import AmbiguousConfigFileError
 from plain2code_read_config import get_args_from_config
 
 CODEPLAIN_API_KEY = os.getenv("CODEPLAIN_API_KEY")
@@ -83,9 +85,51 @@ def frid_range_string(s):
     return s
 
 
+def resolve_config_file(config_name: str, plain_file_path: str):
+    """
+    Resolve the config file path by searching in two locations:
+    1. Directory of the plain file
+    2. Current working directory (where render is called from)
+
+    Returns the resolved absolute path, or None if the file is not found in either location.
+    Raises AmbiguousConfigFileError if the file exists in both locations (and they differ).
+    """
+    plain_file_dir = os.path.dirname(os.path.abspath(plain_file_path))
+    cwd = os.getcwd()
+
+    plain_dir_config = os.path.normpath(os.path.join(plain_file_dir, config_name))
+    cwd_config = os.path.normpath(os.path.join(cwd, config_name))
+
+    in_plain_dir = os.path.exists(plain_dir_config)
+    in_cwd = os.path.exists(cwd_config)
+    same_location = plain_dir_config == cwd_config
+
+    if in_plain_dir and in_cwd and not same_location:
+        raise AmbiguousConfigFileError(
+            f"Config file '{config_name}' was found in two locations:\n"
+            f"  - Plain file directory: {plain_file_dir}\n"
+            f"  - Current working directory: {cwd}\n"
+            f"Remove the config file from one of these locations to resolve the ambiguity."
+        )
+
+    if in_plain_dir:
+        return plain_dir_config
+    if in_cwd:
+        return cwd_config
+    return None
+
+
 def update_args_with_config(args, parser):
     try:
-        config_args = get_args_from_config(args.config_name, parser)
+        resolved_config = resolve_config_file(args.config_name, args.filename)
+
+        if resolved_config is None:
+            console.info(f"No config file '{args.config_name}' found. Proceeding without one.")
+            return args
+
+        args.config_name = resolved_config
+        config_args = get_args_from_config(resolved_config, parser)
+
         # Get all action types from the parser
         action_types = {action.dest: action for action in parser._actions}
 
@@ -109,6 +153,8 @@ def update_args_with_config(args, parser):
             else:
                 parser.error(f"Invalid argument: {key}")
 
+    except AmbiguousConfigFileError as e:
+        parser.error(str(e))
     except Exception as e:
         parser.error(f"Error reading config file: {str(e)}")
 
@@ -152,7 +198,7 @@ def create_parser():
         "--config-name",
         type=non_empty_string,
         default="config.yaml",
-        help="Path to the config file, defaults to config.yaml",
+        help="Name of the config file to look for. Looked up in the plain file directory and the current working directory. Defaults to config.yaml.",
     )
 
     render_range_group = parser.add_mutually_exclusive_group()

{codeplain-0.2.13 → codeplain-0.2.14}/plain2code_exceptions.py

@@ -73,3 +73,9 @@ class NetworkConnectionError(Exception):
     """Raised when there is a network connectivity issue with the API server."""
 
     pass
+
+
+class AmbiguousConfigFileError(Exception):
+    """Raised when a config file is found in both the plain file directory and the current working directory."""
+
+    pass

{codeplain-0.2.13 → codeplain-0.2.14}/plain2code_read_config.py

@@ -1,4 +1,3 @@
-import os
 from argparse import ArgumentParser, Namespace
 from typing import Any, Dict
 
@@ -46,11 +45,6 @@ def get_args_from_config(config_file: str, parser: ArgumentParser) -> Namespace:
 
     args = Namespace()
 
-    if config_file == "config.yaml":
-        if not os.path.exists(config_file):
-            console.info(f"Default config file {config_file} not found. No config file is read.")
-            return args
-
     # Load config
     config = load_config(config_file)
     config = validate_config(config, parser)

codeplain-0.2.14/tests/test_resolve_config_file.py

@@ -0,0 +1,89 @@
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from plain2code_arguments import resolve_config_file
+from plain2code_exceptions import AmbiguousConfigFileError
+
+
+@pytest.fixture
+def two_dirs():
+    """Provide two separate temporary directories: one for the plain file, one as CWD."""
+    with tempfile.TemporaryDirectory() as plain_dir:
+        with tempfile.TemporaryDirectory() as cwd:
+            yield plain_dir, cwd
+
+
+def _plain_file(plain_dir):
+    return os.path.join(plain_dir, "module.plain")
+
+
+def test_config_in_plain_file_dir_only(two_dirs):
+    plain_dir, cwd = two_dirs
+    config = Path(plain_dir) / "config.yaml"
+    config.write_text("verbose: true\n")
+
+    with patch("os.getcwd", return_value=cwd):
+        result = resolve_config_file("config.yaml", _plain_file(plain_dir))
+
+    assert result == os.path.normpath(str(config))
+
+
+def test_config_in_cwd_only(two_dirs):
+    plain_dir, cwd = two_dirs
+    config = Path(cwd) / "config.yaml"
+    config.write_text("verbose: true\n")
+
+    with patch("os.getcwd", return_value=cwd):
+        result = resolve_config_file("config.yaml", _plain_file(plain_dir))
+
+    assert result == os.path.normpath(str(config))
+
+
+def test_config_in_both_locations_raises(two_dirs):
+    plain_dir, cwd = two_dirs
+    (Path(plain_dir) / "config.yaml").write_text("verbose: true\n")
+    (Path(cwd) / "config.yaml").write_text("verbose: false\n")
+
+    with patch("os.getcwd", return_value=cwd):
+        with pytest.raises(AmbiguousConfigFileError) as exc_info:
+            resolve_config_file("config.yaml", _plain_file(plain_dir))
+
+    assert plain_dir in str(exc_info.value)
+    assert cwd in str(exc_info.value)
+
+
+def test_config_not_found_returns_none(two_dirs):
+    plain_dir, cwd = two_dirs
+
+    with patch("os.getcwd", return_value=cwd):
+        result = resolve_config_file("config.yaml", _plain_file(plain_dir))
+
+    assert result is None
+
+
+def test_config_same_dir_no_error():
+    """When the plain file and CWD are in the same directory, a single config file is fine."""
+    with tempfile.TemporaryDirectory() as d:
+        config = Path(d) / "config.yaml"
+        config.write_text("verbose: true\n")
+
+        with patch("os.getcwd", return_value=d):
+            result = resolve_config_file("config.yaml", os.path.join(d, "module.plain"))
+
+    assert result == os.path.normpath(str(config))
+
+
+def test_custom_config_name_found_in_plain_file_dir(two_dirs):
+    """A custom --config-name is also looked up in the two locations."""
+    plain_dir, cwd = two_dirs
+    config = Path(plain_dir) / "myconfig.yaml"
+    config.write_text("verbose: true\n")
+
+    with patch("os.getcwd", return_value=cwd):
+        result = resolve_config_file("myconfig.yaml", _plain_file(plain_dir))
+
+    assert result == os.path.normpath(str(config))

{codeplain-0.2.13 → codeplain-0.2.14}/tui/components.py

@@ -271,6 +271,7 @@ class RenderingInfoBox(Vertical):
         """Initialize default labels on mount."""
         self.module_text = "Module: "
         self.functionality_text = "Functionality:"
+
         self._refresh_content()
 
     def compose(self):
@@ -355,7 +356,7 @@ class FRIDProgress(Vertical):
     CONFORMANCE_TEST_VALIDATION_TEXT = "Conformance tests"
 
     RENDERING_MODULE_TEXT = "Module: "
-    RENDERING_FUNCTIONALITY_TEXT = "Functionality:"
+    RENDERING_FUNCTIONALITY_TEXT = "Functionality "
 
     def __init__(
         self,
@@ -367,7 +368,7 @@ class FRIDProgress(Vertical):
         self.unittests_script = unittests_script
         self.conformance_tests_script = conformance_tests_script
 
-    def update_fr_text(self, text: str) -> None:
+    def update_functionality_text(self, text: str) -> None:
         try:
             # Update the rendering info box instead
             info_box = self.query_one(RenderingInfoBox)

{codeplain-0.2.13 → codeplain-0.2.14}/tui/state_handlers.py

@@ -66,8 +66,9 @@ class FridReadyHandler(StateHandler):
     def handle(self, _: list[str], snapshot: RenderContextSnapshot, _previous_state_segments: list[str]) -> None:
         """Handle READY_FOR_FRID_IMPLEMENTATION state."""
         # Update FRID text
-        rendering_functionality_text = f"{tui_components.FRIDProgress.RENDERING_FUNCTIONALITY_TEXT} {snapshot.frid_context.functional_requirement_text}"
-        get_frid_progress(self.tui).update_fr_text(rendering_functionality_text)
+
+        rendering_functionality_text = f"{tui_components.FRIDProgress.RENDERING_FUNCTIONALITY_TEXT}{snapshot.frid_context.frid}: {snapshot.frid_context.functional_requirement_text}"
+        get_frid_progress(self.tui).update_functionality_text(rendering_functionality_text)
 
         # Set progress states
         update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_RENDER_FR.value, ProgressItem.PROCESSING)
@@ -216,11 +217,21 @@ class ConformanceTestsHandler(StateHandler):
                 )
             elif segments[2] == States.CONFORMANCE_TEST_ENV_PREPARED.value:
                 running_text = f"Running conformance tests for functional requirement {snapshot.conformance_tests_running_context.current_testing_frid}"
+                if snapshot.conformance_tests_running_context.current_testing_module_name != snapshot.module_name:
+                    running_text += (
+                        f" of module {snapshot.conformance_tests_running_context.current_testing_module_name}"
+                    )
+
                 update_progress_item_substates(
                     self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, [Substate(running_text)]
                 )
             elif segments[2] == States.CONFORMANCE_TEST_FAILED.value:
                 fixing_text = f"Fixing conformance tests for functional requirement {snapshot.conformance_tests_running_context.current_testing_frid}"
+                if snapshot.conformance_tests_running_context.current_testing_module_name != snapshot.module_name:
+                    fixing_text += (
+                        f" of module {snapshot.conformance_tests_running_context.current_testing_module_name}"
+                    )
+
                 update_progress_item_substates(
                     self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, [Substate(fixing_text)]
                 )

codeplain-0.2.13/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2.13"