codeplain 0.2.10__tar.gz → 0.2.12__tar.gz

codeplain-0.2.12/.github/workflows/publish-install-script.yml

@@ -0,0 +1,56 @@
+name: Publish Install Scripts to R2
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'install/bash/*.sh'
+      - 'install/powershell/*.ps1'
+  workflow_dispatch:
+
+jobs:
+  publish:
+    name: Upload to Cloudflare R2
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Upload install scripts to R2
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          R2_ENDPOINT: ${{ secrets.R2_ENDPOINT }}
+          R2_BUCKET: ${{ secrets.R2_BUCKET }}
+        run: |
+          aws s3 cp install/bash/install.sh s3://${R2_BUCKET}/install/install.sh \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ install.sh uploaded to R2"
+
+          aws s3 cp install/bash/walkthrough.sh s3://${R2_BUCKET}/install/walkthrough.sh \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ walkthrough.sh uploaded to R2"
+
+          aws s3 cp install/bash/examples.sh s3://${R2_BUCKET}/install/examples.sh \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ examples.sh uploaded to R2"
+
+          aws s3 cp install/powershell/install.ps1 s3://${R2_BUCKET}/install/install.ps1 \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ install.ps1 uploaded to R2"
+
+          aws s3 cp install/powershell/walkthrough.ps1 s3://${R2_BUCKET}/install/walkthrough.ps1 \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ walkthrough.ps1 uploaded to R2"
+
+          aws s3 cp install/powershell/examples.ps1 s3://${R2_BUCKET}/install/examples.ps1 \
+            --endpoint-url "${R2_ENDPOINT}" \
+            --content-type "text/plain"
+          echo "✓ examples.ps1 uploaded to R2"
+

{codeplain-0.2.10 → codeplain-0.2.12}/PKG-INFO

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

codeplain-0.2.12/_version.py

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

{codeplain-0.2.10 → codeplain-0.2.12}/config/system_config.yaml

@@ -1,5 +1,3 @@
-client_version: "0.2.10"
-
 error_messages:
   template_not_found:
     message: |

{codeplain-0.2.10 → codeplain-0.2.12}/docs/plain_language_specification.md

@@ -13,68 +13,31 @@
 Here's an example of a "hello, world" program in ***plain.
 
 ```plain
-***Non-Functional Requirements:***
+***implementation reqs***
 
 - :Implementation: should be in Python.
 
-***Functional Requirements:***
+***functional specs***
 
 - Display "hello, world"
 ```
 
-# Source structure
-
-## Source organization
-
-***plain source can be organized in sections and subsection using markdown headers.
-
-```plain
-# Section 1
-
-# Section 2
-
-***Non-Functional Requirements:***
-
-- First simple non-functional requirement
-
-***Functional Requirements:***
-
-- First simple functional requirement
-
-## Section 2.1
-
-***Non-Functional Requirements:***
-
-- Second simple non-functional requirement
-
-***Functional Requirements:***
-
-- Second simple functional requirement
-```
-
-This enables hierarchical organization of the specification. 
-
-In example above:
-
-- While rendering the "First simple functional requirement", the renderer will not have access to the "Second simple non-functional requirement".
-- While rendering the "Second simple functional requirement", the renderer will not have access to the "First simple non-functional requirement".
-
 ### Specifications
 
 There are four types of specifications:
 
-- `***Definitions:***`
-- `***Non-Functional Requirements:***`
-- `***Functional Requirements:***`
-- `***Test Requirements:***`
+- `***definitions***`
+- `***implementation reqs***`
+- `***functional specs***`
+- `***test reqs***`
 
-Every plain source file requires at least one functional requirement and an associated non-functional requirement.
+Every plain source file requires at least one functional spec and an associated implementation req.
 
-Functional requirements must reside in leaf sections while other specifications can be placed also in non-leaf sections. Specifications in non-leaf sections apply not just to the section itself but to all of its subsections.
+Functional specs must reside in leaf sections while other specifications can be placed also in non-leaf sections. Specifications in non-leaf sections apply not just to the section itself but to all of its subsections.
 
 ## Definitions
 
-The `***Definitions:***` specification is a list of definitions of new concepts.
+The `***definitions***` specification is a list of definitions of new concepts.
 
 Here's an example of a simple definiton.
 
@@ -89,9 +52,9 @@ While providing definitions, you should adhere to the following 4 rules:
 - Every definition must start with the name of the concept you are defining.
 - Each concept name must be enclosed in colons (`:`) at both the beginning and end.
   - Valid characters for concept name include: Plus sign (`+`), Minus sign (`-`), Dot sign (`.`), Digits (`0`-`9`), Uppercase letters (`A`-`Z`), Underscore (`_`), Lowercase letters (`a`-`z`)
-  - Examples: `:App:`, `:Tasks:`, `:ListOfUsers:`, `:CLI:`. 
+  - Examples: `:App:`, `:Tasks:`, `:ListOfUsers:`, `:CLI:`.
 - Concept names must be globally unique (meaning, you cannot provide two definitions with the same concept name).
-- When referencing concepts in ***Test Requirements:***, ***Functional Requirements:***, ***Non-Functional Requirements:*** and ***Acceptance Tests:***, the concept name must exist in the ***Definitions:*** section.
+- When referencing concepts in ***test reqs***, ***functional specs***, ***implementation reqs*** and ***acceptance tests***, the concept name must exist in the ***definitions*** section.
 
 Furthermore, there are special concepts that are already defined and are ready to use. They should not be redefined:
 
@@ -111,9 +74,9 @@ Definitions are the mechanism for definining data structures in ***plain. Here's
   - Due Date - optional date by which :User: is supposed to complete :Task:.
 ```
 
-## Non-Functional Requirements
+## Implementation Reqs
 
-The `***Non-Functional Requirements:***` specification is a list of instructions that steer software code implementation and provide details of execution environment.
+The `***implementation reqs***` specification is a list of instructions that steer software code implementation and provide details of execution environment.
 
 Here's an example of a simple instruction specifying only that the ***plain specification should be rendered to Python software code.
 
@@ -133,9 +96,9 @@ Here's an example of more complex instructions.
 - The main executable file of :App: should be called hello_world.py
 ```
 
-## Functional Requirements
+## Functional Specs
 
-The `***Functional Requirements:***` specification provides a description of functionality that should be rendered to software code. The descriptions should be provided in natural language as a markdown list.
+The `***functional specs***` specification provides a description of functionality that should be rendered to software code. The descriptions should be provided in natural language as a markdown list.
 
 Here's an example of a simple description of the functionality of the "hello, world" application.
 
@@ -143,7 +106,7 @@ Here's an example of a simple description of the functionality of the "hello, wo
 - Display "hello, world"
 ```
 
-Each functional requirement must be limited in complexity. For example, for the functional requirement
+Each functional spec must be limited in complexity. For example, for the functional spec
 
 ```plain
 - :App: should implement a task manager application.
@@ -152,10 +115,10 @@ Each functional requirement must be limited in complexity. For example, for the
 the renderer of ***plain source to software code should respond with
 
 ```
-Functional requirement too complex!
+Functional spec too complex!
 ```
 
-In such case you need to break down the functioanlity into smaller, less-complex functional requirements.
+In such case you need to break down the functioanlity into smaller, less-complex functional specs.
 
 Here's an example how to do such a break down in the case of a task manager application.
 
@@ -173,38 +136,38 @@ Here's an example how to do such a break down in the case of a task manager appl
 - :User: should be able to mark :Task: as completed.
 ```
 
-Functional requirements are rendered incrementally one by one. Consequently earlier functional requirements cannot reference later functional requirements.
+Functional specs are rendered incrementally one by one. Consequently earlier functional specs cannot reference later functional specs.
 
 ### Acceptance Tests
 
-Acceptance tests can be used to further refine the functional requirement and especially to incorporate constraints on the implementation.
+Acceptance tests can be used to further refine the functional spec and especially to incorporate constraints on the implementation.
 
-Acceptance tests are specified with a keyword `***Acceptance Tests:***` as a subsection within `***Functional Requirements:***` section. Each acceptance tests must be an item in a list.
+Acceptance tests are specified with a keyword `***acceptance tests***` as a subsection within `***functional specs***` section. Each acceptance tests must be an item in a list.
 
 Here's an example of a "Hello, World" application with one acceptance test.
 
 ```plain
-***Functional Requirements:***
+***functional specs***
 
 - Display "hello, world"
 
-  ***Acceptance Tests:***
-    
+  ***acceptance tests***
+
   - :App: shouldn't show logging output in the console output (neither in stdout nor stderr).
 ```
 
-Acceptance tests extend **conformance tests**. The acceptance tests are implemented according to the ***Test Requirements:*** specification (see next section).
+Acceptance tests extend **conformance tests**. The acceptance tests are implemented according to the ***test reqs*** specification (see below).
 
-## Test Requirements
+## Test Reqs
 
-The `***Test Requirements:***` specification is a list of instructions that steer implementation of conformance tests and provide details of testing environment.
+The `***test reqs***` specification is a list of instructions that steer implementation of conformance tests and provide details of testing environment.
 
-**Conformance tests** is the generated code used to verify that the functional requirement is implemented according to the specification.
+**Conformance tests** is the generated code used to verify that the functional spec is implemented according to the specification.
 
-Here's an example specification of test requirements.
+Here's an example specification of test reqs.
 
 ```plain
-- :ConformanceTests: of :App: should be implemented in Python using Unittest framework. 
+- :ConformanceTests: of :App: should be implemented in Python using Unittest framework.
 ```
 
 # Extended Syntax

{codeplain-0.2.10 → codeplain-0.2.12}/file_utils.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+import stat
 from pathlib import Path
 
 from liquid2 import Environment, FileSystemLoader, StrictUndefined
@@ -46,6 +47,11 @@ FILE_EXTENSION_MAPPING = {
 SYSTEM_FOLDERS = [".git", CODEPLAIN_METADATA_FOLDER, CODEPLAIN_MEMORY_SUBFOLDER]
 
 
+def is_system_folder_path(file_path: str) -> bool:
+    parts = Path(file_path).parts
+    return bool(parts) and parts[0] in SYSTEM_FOLDERS
+
+
 def get_file_type(file_name):
 
     # Extract the file extension
@@ -94,7 +100,22 @@ def list_folders_in_directory(directory):
 # delete a folder and all its subfolders and files
 def delete_folder(folder_name):
     if os.path.exists(folder_name):
-        shutil.rmtree(folder_name)
+        # Use writable-aware deletion so read-only files (e.g. .git objects on Windows) don't cause PermissionError
+        delete_files_and_subfolders(folder_name)
+        _make_writable(folder_name)
+        os.rmdir(folder_name)
+
+
+def _make_writable(path: str) -> None:
+    """On Windows, clear read-only so deletion can succeed."""
+    # TODO - Check if this can be done in a cleaner way.
+    is_windows = os.name == "nt"
+    if is_windows:
+        try:
+            mode = os.stat(path).st_mode
+            os.chmod(path, mode | stat.S_IWRITE)
+        except OSError:
+            pass
 
 
 def delete_files_and_subfolders(directory):
@@ -106,12 +127,14 @@ def delete_files_and_subfolders(directory):
         # Delete files
         for file in files:
             file_path = os.path.join(root, file)
+            _make_writable(file_path)
             os.remove(file_path)
             total_files_deleted += 1
 
         # Delete directories
         for dir_ in dirs:
             dir_path = os.path.join(root, dir_)
+            _make_writable(dir_path)
             os.rmdir(dir_path)
             total_folders_deleted += 1
 

{codeplain-0.2.10/install → codeplain-0.2.12/install/bash}/install.sh

@@ -219,9 +219,13 @@ echo -e "${GRAY}─────────────────────
 echo -e "  ${YELLOW}${BOLD}You're all set!${NC}"
 echo -e "${GRAY}────────────────────────────────────────────${NC}"
 echo ""
-echo -e "  thank you for using *codeplain!"
+echo -e "  thank you for using ${YELLOW}*codeplain!${NC}"
 echo ""
-echo -e "  learn more at ${YELLOW}https://plainlang.org/${NC}"
+echo -e "  ${BOLD}next steps:${NC}"
+echo ""
+echo -e "  join our Discord community: ${YELLOW}https://discord.gg/4qQJaMu7Y${NC}"
+echo ""
+echo -e "  learn more about ${YELLOW}***plain${NC} at ${YELLOW}https://plainlang.org/${NC}"
 echo ""
 echo -e "  ${GREEN}happy development!${NC} 🚀"
 echo ""

codeplain-0.2.12/install/powershell/examples.ps1

@@ -0,0 +1,99 @@
+$ErrorActionPreference = 'Stop'
+
+# Brand Colors (use exported colors if available, otherwise define them)
+if (-not $env:YELLOW)     { $YELLOW      = "$([char]27)[38;2;224;255;110m" } else { $YELLOW      = $env:YELLOW }
+if (-not $env:GREEN)      { $GREEN       = "$([char]27)[38;2;121;252;150m" } else { $GREEN       = $env:GREEN }
+if (-not $env:RED)        { $RED         = "$([char]27)[38;2;239;68;68m"   } else { $RED         = $env:RED }
+if (-not $env:GRAY)       { $GRAY        = "$([char]27)[38;2;128;128;128m" } else { $GRAY        = $env:GRAY }
+if (-not $env:BOLD)       { $BOLD        = "$([char]27)[1m"               } else { $BOLD        = $env:BOLD }
+if (-not $env:NC)         { $NC          = "$([char]27)[0m"               } else { $NC          = $env:NC }
+
+# Examples configuration
+$EXAMPLES_FOLDER_NAME = "plainlang-examples"
+$EXAMPLES_DOWNLOAD_URL = "https://github.com/Codeplain-ai/plainlang-examples/archive/refs/tags/0.1.zip"
+
+# Show current directory and ask for extraction path
+$CURRENT_DIR = Get-Location
+Write-Host "  current folder: ${YELLOW}${CURRENT_DIR}${NC}"
+Write-Host ""
+Write-Host "  extract examples here, or enter a different path:"
+Write-Host ""
+$EXTRACT_PATH = Read-Host "  [Enter for current, or type path]"
+Write-Host ""
+
+# Use current directory if empty
+if (-not $EXTRACT_PATH) {
+    $EXTRACT_PATH = "$CURRENT_DIR"
+}
+
+# Expand ~ to home directory
+if ($EXTRACT_PATH.StartsWith("~")) {
+    $EXTRACT_PATH = $EXTRACT_PATH -replace "^~", $HOME
+}
+
+$SKIP_DOWNLOAD = $false
+
+# Check if directory exists, create if not
+if (-not (Test-Path $EXTRACT_PATH -PathType Container)) {
+    Write-Host "  ${GRAY}creating directory...${NC}"
+    try {
+        New-Item -ItemType Directory -Path $EXTRACT_PATH -Force | Out-Null
+    } catch {
+        Write-Host "  ${RED}✗${NC} failed to create directory: ${EXTRACT_PATH}"
+        Write-Host "  ${GRAY}skipping example download.${NC}"
+        $SKIP_DOWNLOAD = $true
+    }
+}
+
+if (-not $SKIP_DOWNLOAD) {
+    Write-Host "  ${GRAY}downloading examples...${NC}"
+
+    $TEMP_ZIP = Join-Path ([System.IO.Path]::GetTempPath()) "plainlang-examples.zip"
+
+    try {
+        Invoke-WebRequest -Uri $EXAMPLES_DOWNLOAD_URL -OutFile $TEMP_ZIP -UseBasicParsing
+
+        if (Test-Path $TEMP_ZIP) {
+            Write-Host "  ${GRAY}extracting to ${EXTRACT_PATH}...${NC}"
+
+            try {
+                Expand-Archive -Path $TEMP_ZIP -DestinationPath $EXTRACT_PATH -Force
+
+                # Find and rename extracted directory to remove version number
+                $EXTRACTED_DIR = Join-Path $EXTRACT_PATH $EXAMPLES_FOLDER_NAME
+                $VERSIONED_DIR = Get-ChildItem -Path $EXTRACT_PATH -Directory -Filter "${EXAMPLES_FOLDER_NAME}-*" | Select-Object -First 1
+
+                if ($VERSIONED_DIR) {
+                    if (Test-Path $EXTRACTED_DIR) {
+                        Remove-Item -Path $EXTRACTED_DIR -Recurse -Force -ErrorAction SilentlyContinue
+                    }
+                    Rename-Item -Path $VERSIONED_DIR.FullName -NewName $EXAMPLES_FOLDER_NAME
+                }
+
+                # Remove the .gitignore file from the root of the extracted directory
+                $GITIGNORE_PATH = Join-Path $EXTRACTED_DIR ".gitignore"
+                if (Test-Path $GITIGNORE_PATH) {
+                    Remove-Item -Path $GITIGNORE_PATH -Force
+                }
+
+                Write-Host ""
+                Write-Host "  ${GREEN}✓${NC} examples downloaded successfully!"
+                Write-Host ""
+                Write-Host "  examples are in: ${YELLOW}${EXTRACTED_DIR}${NC}"
+                Write-Host ""
+            } catch {
+                Write-Host "  ${RED}✗${NC} failed to extract examples."
+            }
+
+            Remove-Item -Path $TEMP_ZIP -Force -ErrorAction SilentlyContinue
+        } else {
+            Write-Host "  ${RED}✗${NC} failed to download examples."
+        }
+    } catch {
+        Write-Host "  ${RED}✗${NC} failed to download examples."
+        Remove-Item -Path $TEMP_ZIP -Force -ErrorAction SilentlyContinue
+    }
+
+    Write-Host ""
+    Read-Host "  press [Enter] to continue..."
+}