Compare commits
61
Commits
1.5.0-RC
...
2414da59a7
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2414da59a7 | ||
|
|
fd6d05d568 | ||
|
|
caad7d8ab9 | ||
|
|
88b0bb2147 | ||
|
|
38646c6257 | ||
|
|
f61ac35580 | ||
|
|
9bee0aed5b | ||
|
|
cd7e001f41 | ||
|
|
62520f6203 | ||
|
|
d0aaa2c256 | ||
|
|
5346d15a9f | ||
|
|
7578128689 | ||
|
|
71243b6bde | ||
|
|
7b65ff9d0e | ||
|
|
d409a4bb8b | ||
|
|
f168e9f6ed | ||
|
|
a051280e0c | ||
|
|
fc01016a74 | ||
|
|
446c8d9a6e | ||
|
|
c140567e0c | ||
|
|
311cf6ee44 | ||
|
|
3e338f3d53 | ||
|
|
c097464750 | ||
|
|
6e9333844e | ||
|
|
a976702caf | ||
|
|
850efedb72 | ||
|
|
f845213332 | ||
|
|
cdd48ec871 | ||
|
|
286ec30422 | ||
|
|
8a560f5417 | ||
|
|
966b6a31ae | ||
|
|
c3c0a3292b | ||
|
|
aa9565b40b | ||
|
|
05d7432b37 | ||
|
|
c7c333b71a | ||
|
|
e55d9c835a | ||
|
|
83d8c8b71f | ||
|
|
a72991d1b7 | ||
|
|
cd007050a8 | ||
|
|
418b1ae2b6 | ||
|
|
b0fb65a036 | ||
|
|
86e8b2e2bc | ||
|
|
a98fe51983 | ||
|
|
f8d36beae1 | ||
|
|
580256d520 | ||
|
|
5ab074ba9e | ||
|
|
4269310beb | ||
|
|
7c059b4741 | ||
|
|
217787e17a | ||
|
|
9ddc7dbee6 | ||
|
|
24937c7cf5 | ||
|
|
ecc4d8b9ed | ||
|
|
3d8bfe8863 | ||
|
|
3b83439788 | ||
|
|
0af0f31e48 | ||
|
|
d17ad9ef0d | ||
|
|
222a653040 | ||
|
|
f24c7d2715 | ||
|
|
2546a5327f | ||
|
|
4df6612eca | ||
|
|
2a79c718ba |
No files matched your search
@@ -27,3 +27,4 @@ debug.log
|
||||
/compile_jvm_output.txt
|
||||
/compile_metadata_output.txt
|
||||
test_output*.txt
|
||||
/site/src/version-template/lyng-version.js
|
||||
@@ -5,6 +5,14 @@
|
||||
- For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`.
|
||||
- Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface.
|
||||
- Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above.
|
||||
- Prefer the shortest clear loop: use `for` for straightforward iteration/ranges; use `while` only when loop state/condition is irregular or changes in ways `for` cannot express cleanly.
|
||||
- In Lyng code, slice strings with range indexing (`text[a..<b]`, `text[..<n]`, `text[n..]`) and avoid Java/Kotlin-style `substring(...)`.
|
||||
|
||||
## Lyng-First API Declarations
|
||||
- Use `.lyng` declarations as the single source of truth for Lyng-facing API docs and types (especially module extern declarations).
|
||||
- Prefer defining Lyng entities (enums/classes/type shapes) in `.lyng` files; only define them in Kotlin when there is Kotlin/platform-specific implementation detail that cannot be expressed in Lyng.
|
||||
- Avoid hardcoding Lyng API documentation in Kotlin registrars when it can be declared in `.lyng`; Kotlin-side docs should be fallback/bridge only.
|
||||
- For mixed pluggable modules (Lyng + Kotlin), embed module `.lyng` sources as generated Kotlin string literals, evaluate them into module scope during registration, then attach Kotlin implementations/bindings.
|
||||
|
||||
## Kotlin/Wasm generation guardrails
|
||||
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
|
||||
|
||||
+73
-141
@@ -1,156 +1,88 @@
|
||||
## 1.5.0-SNAPSHOT
|
||||
# Changelog
|
||||
|
||||
### Language Features
|
||||
- Added `return` statement with local and non-local exit support (`return@label`).
|
||||
- Support for `abstract` classes, methods, and variables.
|
||||
- Introduced `interface` as a synonym for `abstract class`.
|
||||
- Multiple Inheritance (MI) completed and enabled by default (C3 MRO).
|
||||
- Class properties with custom accessors (`get`, `set`).
|
||||
- Restricted setter visibility (`private set`, `protected set`).
|
||||
- Late-initialized `val` fields in classes with `Unset` protection.
|
||||
- Named arguments (`name: value`) and named splats (`...Map`).
|
||||
- Assign-if-null operator `?=`.
|
||||
- Refined `protected` visibility rules and `closed` modifier.
|
||||
- Transient attribute `@Transient` for serialization and equality.
|
||||
- Unified Delegation model for `val`, `var`, and `fun`.
|
||||
- Singleton objects (`object`) and object expressions.
|
||||
This file tracks user-visible Lyng language/runtime/tooling changes.
|
||||
|
||||
### Standard Library
|
||||
- Added `with(self, block)` for scoped execution.
|
||||
- Added `clamp()` function and extension.
|
||||
- Improved `Exception` and `StackTraceEntry` reporting.
|
||||
History note:
|
||||
- The project had periods where changelog maintenance lagged behind commits.
|
||||
- Entries below are synchronized and curated for `1.5.x`.
|
||||
- Earlier history may be incomplete and should be cross-checked with git tags/commits when needed.
|
||||
|
||||
### Tooling and IDE
|
||||
- **CLI**: Added `fmt` as a first-class subcommand for code formatting.
|
||||
- **IDEA Plugin**: Lightweight autocompletion (experimental), improved docs, and Grazie integration.
|
||||
- **Highlighters**: Updated TextMate bundle and website highlighters for new syntax.
|
||||
## 1.5.1 (2026-03-25)
|
||||
|
||||
### Detailed Changes:
|
||||
### Language
|
||||
- Added string interpolation:
|
||||
- `"$name"` identifier interpolation.
|
||||
- `"${expr}"` expression interpolation.
|
||||
- Added literal-dollar forms in strings:
|
||||
- `"\$"` -> `$`
|
||||
- `"$$"` -> `$`
|
||||
- `\\$x` is parsed as backslash + interpolation of `x`.
|
||||
- Added per-file interpolation opt-out via leading directive comment:
|
||||
- `// feature: interpolation: off`
|
||||
|
||||
- Language: Refined `protected` visibility rules
|
||||
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor).
|
||||
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass.
|
||||
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic.
|
||||
### Docs and AI references
|
||||
- Updated compiler-accurate AI language docs:
|
||||
- interpolation syntax and escaping
|
||||
- per-file feature switch behavior
|
||||
- Refreshed tutorial examples and doctests to reflect new interpolation semantics.
|
||||
- Added/reworked current proposal/reference materials for Lyng common-platform guidance.
|
||||
|
||||
- Language: Added `return` statement
|
||||
- `return [expression]` exits the innermost enclosing callable (function or lambda).
|
||||
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`).
|
||||
- Named functions automatically provide their name as a label for non-local returns.
|
||||
- Labeled lambdas: lambdas can be explicitly labeled using `@label { ... }`.
|
||||
- Restriction: `return` is forbidden in shorthand function definitions (e.g., `fun f(x) = return x` is a syntax error).
|
||||
- Control Flow: `return` and `break` are now protected from being caught by user-defined `try-catch` blocks in Lyng.
|
||||
- Documentation: New `docs/return_statement.md` and updated `tutorial.md`.
|
||||
### Compatibility notes
|
||||
- Interpolation is enabled by default for normal string literals.
|
||||
- Existing code that intentionally used `$name` as literal text should use `\$name`, `$$name`, or the file directive `// feature: interpolation: off`.
|
||||
|
||||
- Language: stdlib improvements
|
||||
- Added `with(self, block)` function to `root.lyng` which executes a block with `this` set to the provided object.
|
||||
- Language: Abstract Classes and Interfaces
|
||||
- Support for `abstract` modifier on classes, methods, and variables.
|
||||
- Introduced `interface` as a synonym for `abstract class`, supporting full state (constructors, fields, `init` blocks) and implementation by parts via MI.
|
||||
- New `closed` modifier (antonym to `open`) to prevent overriding class members.
|
||||
- Refined `override` logic: mandatory keyword when re-declaring members that exist in the ancestor chain (MRO).
|
||||
- MI Satisfaction: Abstract requirements are automatically satisfied by matching concrete members found later in the C3 MRO chain without requiring explicit proxy methods.
|
||||
- Integration: Updated highlighters (lynglib, lyngweb, IDEA plugin), IDEA completion, and Grazie grammar checking.
|
||||
- Documentation: Updated `docs/OOP.md` with sections on "Abstract Classes and Members", "Interfaces", and "Overriding and Virtual Dispatch".
|
||||
- IDEA plugin: Improved natural language support and spellchecking
|
||||
- Disabled the limited built-in English and Technical dictionaries.
|
||||
- Enforced usage of the platform's standard Natural Languages (Grazie) and Spellchecker components.
|
||||
- Integrated `SpellCheckerManager` for word suggestions and validation, respecting users' personal and project dictionaries.
|
||||
- Added project-specific "learned words" support via `Lyng Formatter` settings and quick-fixes.
|
||||
- Enhanced fallback spellchecker for technical terms and Lyng-specific vocabulary.
|
||||
## 1.5.0 (2026-03-22)
|
||||
|
||||
- Language: Class properties with accessors
|
||||
- Support for `val` (read-only) and `var` (read-write) properties in classes.
|
||||
- Syntax: `val name [ : Type ] get() { body }` or `var name [ : Type ] get() { body } set(value) { body }`.
|
||||
- Laconic Expression Shorthand: `val prop get() = expression` and `var prop get() = read set(v) = write`.
|
||||
- Properties are pure accessors and do **not** have automatic backing fields.
|
||||
- Validation: `var` properties must have both accessors; `val` must have only a getter.
|
||||
- Integration: Updated TextMate grammar and IntelliJ plugin (highlighting + keywords).
|
||||
- Documentation: New "Properties" section in `docs/OOP.md`.
|
||||
### Major runtime/compiler direction
|
||||
- Completed migration to bytecode-first/bytecode-only execution paths.
|
||||
- Removed interpreter fallback behavior in core execution hot paths.
|
||||
- Continued frame-slot-first local/capture model improvements and related diagnostics.
|
||||
|
||||
- Language: Restricted Setter Visibility
|
||||
- Support for `private set` and `protected set` modifiers on `var` fields and properties.
|
||||
- Allows members to be publicly readable but only writable from within the declaring class or its subclasses.
|
||||
- Enforcement at runtime: throws `AccessException` on unauthorized writes.
|
||||
- Supported only for declarations in class bodies (fields and properties).
|
||||
- Documentation: New "Restricted Setter Visibility" section in `docs/OOP.md`.
|
||||
### Language features and semantics
|
||||
- Added/finished `return` semantics including labeled non-local forms (`return@label`).
|
||||
- Added abstract classes/members and `interface` support (as abstract-class-style construct).
|
||||
- Completed and enabled multiple inheritance with C3 MRO by default.
|
||||
- Added class properties with accessors (`get`/`set`) and restricted setter visibility (`private set`, `protected set`).
|
||||
- Added late-initialized class `val` support with `Unset` protection rules.
|
||||
- Added named arguments (`name: value`) and named splats (`...map`) with stricter validation.
|
||||
- Added assign-if-null operator `?=`.
|
||||
- Improved nullable/type-checking behavior (including `T is nullable` and related type checks).
|
||||
- Added variadic function types (`...` in function type declarations) and tighter lambda type checks.
|
||||
|
||||
- Language: Late-initialized `val` fields in classes
|
||||
- Support for declaring `val` without an immediate initializer in class bodies.
|
||||
- Compulsory initialization: every late-init `val` must be assigned at least once within the class body or an `init` block.
|
||||
- Write-once enforcement: assigning to a `val` is allowed only if its current value is `Unset`.
|
||||
- Access protection: reading a late-init `val` before it is assigned returns the `Unset` singleton; using `Unset` for most operations throws an `UnsetException`.
|
||||
- Extension properties do not support late-init.
|
||||
- Documentation: New "Late-initialized `val` fields" and "The `Unset` singleton" sections in `docs/OOP.md`.
|
||||
### Type system and collections
|
||||
- Added immutable collections hierarchy (`ImmutableList`, `ImmutableSet`, `ImmutableMap`).
|
||||
- Improved generic runtime binding/checking for explicit type arguments and bounds.
|
||||
- Added smarter type-aware collection ops (`+=`, `-=`) and stronger declared-member type checks.
|
||||
|
||||
- Docs: OOP improvements
|
||||
- New page: `docs/scopes_and_closures.md` detailing `ClosureScope` resolution order, recursion‑safe helpers (`chainLookupIgnoreClosure`, `chainLookupWithMembers`, `baseGetIgnoreClosure`), cycle prevention, and capturing lexical environments for callbacks (`snapshotForClosure`).
|
||||
- Updated: `docs/advanced_topics.md` (link to the new page), `docs/parallelism.md` (closures in `launch`/`flow`), `docs/OOP.md` (visibility from closures with preserved `currentClassCtx`), `docs/exceptions_handling.md` (compatibility alias `SymbolNotFound`).
|
||||
- Tutorial: added quick link to Scopes and Closures.
|
||||
### Extern/Kotlin bridge
|
||||
- Tightened extern declaration rules:
|
||||
- explicit extern members are required for extern class/object declarations.
|
||||
- Improved extern generic class behavior and diagnostics.
|
||||
- Extended bridge APIs for binding global functions/variables and object/member interop scenarios.
|
||||
|
||||
- IDEA plugin: Lightweight autocompletion (experimental)
|
||||
- Global completion: local declarations, in‑scope parameters, imported modules, and stdlib symbols.
|
||||
- Member completion: after a dot, suggests only members of the inferred receiver type (incl. chained calls like `Path(".." ).lines().` → `Iterator` methods). No global identifiers appear after a dot.
|
||||
- Inheritance-aware: direct class members first, then inherited (e.g., `List` includes `Collection`/`Iterable` methods).
|
||||
- Heuristics: handles literals (`"…"` → `String`, numbers → `Int/Real`, `[...]` → `List`, `{...}` → `Dict`) and static `Namespace.` members.
|
||||
- Performance: capped results, early prefix filtering, per‑document MiniAst cache, cancellation checks.
|
||||
- Toggle: Settings | Lyng Formatter → "Enable Lyng autocompletion (experimental)" (default ON).
|
||||
- Stabilization: DEBUG completion/Quick Doc logs are OFF by default; behavior aligned between IDE and isolated engine tests.
|
||||
### Standard library and modules
|
||||
- Added `lyng.observable` improvements (`ObservableList` hooks/events).
|
||||
- Added `Random` stdlib API used by updated samples.
|
||||
- Added/extended `lyngio.console` support and CLI integration for console interaction.
|
||||
- Migrated time APIs to `kotlin.time` (`Instant` migration and related docs/tests).
|
||||
|
||||
- Language: Named arguments and named splats
|
||||
- New call-site syntax for named arguments using colon: `name: value`.
|
||||
- Positional arguments must come before named; positionals after a named argument inside parentheses are rejected.
|
||||
- Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal.
|
||||
- Named splats: `...` can now expand a Map into named arguments.
|
||||
- Only string keys are allowed; non-string keys raise a clear error.
|
||||
- Duplicate assignment across named args and named splats is an error.
|
||||
- Ellipsis (variadic) parameters remain positional-only and cannot be named.
|
||||
- Rationale: `=` is assignment and an expression in Lyng; `:` at call sites avoids ambiguity. Declarations keep `name: Type`; call-site casts continue to use `as` / `as?`.
|
||||
- Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases.
|
||||
- Tests added covering success cases and errors for named args/splats and trailing-lambda interactions.
|
||||
### CLI, IDE, and docs/tooling
|
||||
- CLI:
|
||||
- added first-class `fmt` command
|
||||
- preserved direct script fast-path invocation
|
||||
- improved command help/dispatch behavior
|
||||
- IntelliJ plugin:
|
||||
- improved lightweight completion and documentation/inspection behavior
|
||||
- continued highlighter and Grazie/spellchecking integration work
|
||||
- Docs:
|
||||
- substantial updates across tutorial/OOP/type/runtime references
|
||||
- expanded bytecode and advanced topics coverage
|
||||
|
||||
- Tooling: Highlighters and TextMate bundle updated for named args
|
||||
- Website/editor highlighter (lyngweb + site) works with `name: value` and `...Map("k" => v)`; added JS tests covering punctuation/operator spans for `:` and `...`.
|
||||
- TextMate grammar updated to recognize named call arguments: `name: value` after `(` or `,` with `name` highlighted as `variable.parameter.named.lyng` and `:` as punctuation; excludes `::`.
|
||||
- TextMate bundle version bumped to 0.0.3; README updated with details and guidance.
|
||||
## Migration checklist for 1.5.x
|
||||
|
||||
- Multiple Inheritance (MI) completed and enabled by default:
|
||||
- Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds.
|
||||
- Qualified dispatch:
|
||||
- `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor.
|
||||
- Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`).
|
||||
- Field inheritance (`val`/`var`) under MI:
|
||||
- Instance storage is disambiguated per declaring class; unqualified read/write resolves to the first match in MRO.
|
||||
- Qualified read/write targets the chosen ancestor’s storage.
|
||||
- Constructors and initialization:
|
||||
- Direct bases are initialized left-to-right; each ancestor is initialized at most once (diamond-safe de-duplication).
|
||||
- Header-specified constructor arguments are passed to direct bases.
|
||||
- Visibility enforcement under MI:
|
||||
- `private` visible only inside the declaring class body.
|
||||
- `protected` visible inside the declaring class and its transitive subclasses. Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Unrelated contexts cannot access it (qualification/casts do not bypass).
|
||||
- Diagnostics improvements:
|
||||
- Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
|
||||
- Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
|
||||
- `as`/`as?` cast errors include actual and target type names.
|
||||
|
||||
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
|
||||
|
||||
- CLI: Added `fmt` as a first-class Clikt subcommand.
|
||||
- Default behavior: formats files to stdout (no in-place edits by default).
|
||||
- Options:
|
||||
- `--check`: check only; print files that would change; exit with code 2 if any changes are needed.
|
||||
- `-i, --in-place`: write formatted result back to files.
|
||||
- `--spacing`: apply spacing normalization.
|
||||
- `--wrap`, `--wrapping`: enable line wrapping.
|
||||
- Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1.
|
||||
- Multi-file stdout prints headers `--- <path> ---` per file.
|
||||
- `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help.
|
||||
- Fix: Property accessors (`get`, `set`, `private set`, `protected set`) are now correctly indented relative to the property declaration.
|
||||
- Fix: Indentation now correctly carries over into blocks that start on extra‑indented lines (e.g., nested `if` statements or property accessor bodies).
|
||||
- Fix: Formatting Markdown files no longer deletes content in `.lyng` code fences and works correctly with injected files (resolves clobbering, `StringIndexOutOfBoundsException`, and `nonempty text is not covered by block` errors).
|
||||
|
||||
- CLI: Preserved legacy script invocation fast-paths:
|
||||
- `lyng script.lyng [args...]` executes the script directly.
|
||||
- `lyng -- -file.lyng [args...]` executes a script whose name begins with `-`.
|
||||
|
||||
- CLI: Fixed a regression where the root help banner could print before subcommands.
|
||||
- Root command no longer prints help when a subcommand (e.g., `fmt`) is invoked.
|
||||
- If you rely on literal `$...` strings:
|
||||
- replace with `\$...` or `$$...`, or
|
||||
- add `// feature: interpolation: off` at file top.
|
||||
- Review any code relying on interpreter-era fallback behavior; 1.5.x assumes bytecode-first execution.
|
||||
- For extern declarations, ensure members are explicitly declared where required.
|
||||
- For named arguments/splats, verify call sites follow stricter ordering/duplication rules.
|
||||
@@ -93,42 +93,49 @@ import net.sergeych.lyng.*
|
||||
// we need a coroutine to start, as Lyng
|
||||
// is a coroutine based language, async topdown
|
||||
runBlocking {
|
||||
assert(5 == eval(""" 3*3 - 4 """).toInt())
|
||||
eval(""" println("Hello, Lyng!") """)
|
||||
val session = EvalSession()
|
||||
assert(5 == session.eval(""" 3*3 - 4 """).toInt())
|
||||
session.eval(""" println("Hello, Lyng!") """)
|
||||
}
|
||||
```
|
||||
|
||||
### Exchanging information
|
||||
|
||||
Script is executed over some `Scope`. Create instance,
|
||||
add your specific vars and functions to it, and call:
|
||||
The preferred host runtime is `EvalSession`. It owns the script scope and any coroutines
|
||||
started with `launch { ... }`. Create a session, grab its scope when you need low-level
|
||||
binding APIs, then execute scripts through the session:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.*
|
||||
|
||||
// simple function
|
||||
val scope = Script.newScope().apply {
|
||||
addFn("sumOf") {
|
||||
var sum = 0.0
|
||||
for (a in args) sum += a.toDouble()
|
||||
ObjReal(sum)
|
||||
}
|
||||
addConst("LIGHT_SPEED", ObjReal(299_792_458.0))
|
||||
runBlocking {
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope().apply {
|
||||
// simple function
|
||||
addFn("sumOf") {
|
||||
var sum = 0.0
|
||||
for (a in args) sum += a.toDouble()
|
||||
ObjReal(sum)
|
||||
}
|
||||
addConst("LIGHT_SPEED", ObjReal(299_792_458.0))
|
||||
|
||||
// callback back to kotlin to some suspend fn, for example::
|
||||
// suspend fun doSomeWork(text: String): Int
|
||||
addFn("doSomeWork") {
|
||||
// this _is_ a suspend lambda, we can call suspend function,
|
||||
// and it won't consume the thread.
|
||||
// note that in kotlin handler, `args` is a list of `Obj` arguments
|
||||
// and return value from this lambda should be Obj too:
|
||||
doSomeWork(args[0]).toObj()
|
||||
// callback back to kotlin to some suspend fn, for example::
|
||||
// suspend fun doSomeWork(text: String): Int
|
||||
addFn("doSomeWork") {
|
||||
// this _is_ a suspend lambda, we can call suspend function,
|
||||
// and it won't consume the thread.
|
||||
// note that in kotlin handler, `args` is a list of `Obj` arguments
|
||||
// and return value from this lambda should be Obj too:
|
||||
doSomeWork(args[0]).toObj()
|
||||
}
|
||||
}
|
||||
|
||||
// execute through the session:
|
||||
session.eval("sumOf(1,2,3)") // <- 6
|
||||
}
|
||||
// adding constant:
|
||||
scope.eval("sumOf(1,2,3)") // <- 6
|
||||
```
|
||||
Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls.
|
||||
Note that the session reuses one scope, so state persists across `session.eval(...)` calls.
|
||||
Use raw `Scope.eval(...)` only when you intentionally want low-level control without session-owned coroutine lifecycle.
|
||||
|
||||
## IntelliJ IDEA plugin: Lightweight autocompletion (experimental)
|
||||
|
||||
@@ -221,17 +228,15 @@ All of this is documented in the [language site](https://lynglang.com) and local
|
||||
|
||||
- [x] site with integrated interpreter to give a try
|
||||
- [x] kotlin part public API good docs, integration focused
|
||||
- [ ] type specifications
|
||||
- [x] type specifications
|
||||
- [x] Textmate Bundle
|
||||
- [x] IDEA plugin
|
||||
- [ ] source docs and maybe lyng.md to a standard
|
||||
- [ ] metadata first class access from lyng
|
||||
- [x] source docs and maybe lyng.md to a standard
|
||||
- [x] aggressive optimizations
|
||||
- [ ] compile to JVM bytecode optimization
|
||||
|
||||
## After 1.5 "Ideal scripting"
|
||||
|
||||
Estimated summer 2026
|
||||
* __we are here now ;)__
|
||||
|
||||
- propose your feature!
|
||||
|
||||
@@ -239,8 +244,12 @@ Estimated summer 2026
|
||||
|
||||
@-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project.
|
||||
|
||||
__Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, design, implementation.
|
||||
<img src="https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=32&d=identicon" alt="Sergey Chernov" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Sergey Chernov</b> @sergeych, real.sergeych@gmail.com: Initial idea and architecture, language concept, design, implementation.
|
||||
|
||||
<br/>
|
||||
|
||||
<img src="https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=32&d=identicon" alt="Yulia Nezhinskaya" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Yulia Nezhinskaya</b> @AlterEgoJuliaN, neleka88@gmail.com: System analysis, math and feature design.
|
||||
|
||||
|
||||
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
|
||||
|
||||
[parallelism]: docs/parallelism.md
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -1,7 +0,0 @@
|
||||
# Bytecode Migration Plan (Archived)
|
||||
|
||||
Status: completed.
|
||||
|
||||
Historical reference:
|
||||
- `notes/archive/bytecode_migration_plan.md` (full plan)
|
||||
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
|
||||
@@ -4,6 +4,13 @@ It's an interface if the [Collection] that provides indexing access, like `array
|
||||
Array therefore implements [Iterable] too. Well known implementations of `Array` are
|
||||
[List] and [ImmutableList].
|
||||
|
||||
The language-level bracket syntax supports one or more selectors:
|
||||
|
||||
- `value[i]`
|
||||
- `value[i, j]`
|
||||
|
||||
Concrete array-like types decide what selectors they accept. Built-in list-like arrays use one selector at a time; custom types such as matrices may interpret multiple selectors.
|
||||
|
||||
Array adds the following methods:
|
||||
|
||||
## Binary search
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
# Complex Numbers (`lyng.complex`)
|
||||
|
||||
`lyng.complex` adds a pure-Lyng `Complex` type backed by `Real` components.
|
||||
|
||||
Import it when you want ordinary complex arithmetic:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
```
|
||||
|
||||
## Construction
|
||||
|
||||
Use any of these:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
val a = Complex(1.0, 2.0)
|
||||
val b = complex(1.0, 2.0)
|
||||
val c = 2.i
|
||||
val d = 3.re
|
||||
|
||||
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
|
||||
```
|
||||
|
||||
Convenience extensions:
|
||||
|
||||
- `Int.re`, `Real.re`: embed a real value into the complex plane
|
||||
- `Int.i`, `Real.i`: create a pure imaginary value
|
||||
- `cis(angle)`: shorthand for `cos(angle) + i sin(angle)`
|
||||
|
||||
## Core Operations
|
||||
|
||||
`Complex` supports:
|
||||
|
||||
- `+`
|
||||
- `-`
|
||||
- `*`
|
||||
- `/`
|
||||
- unary `-`
|
||||
- `conjugate`
|
||||
- `magnitude`
|
||||
- `phase`
|
||||
|
||||
Mixed arithmetic with `Int` and `Real` is enabled through `lyng.operators`, so both sides work naturally:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
|
||||
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
|
||||
assertEquals(Complex(2.0, 2.0), 2.i + 2)
|
||||
```
|
||||
|
||||
Mixed equality with built-in numeric types is intentionally not promised yet. Keep equality checks in the `Complex` domain for now.
|
||||
|
||||
## Transcendental Functions
|
||||
|
||||
For now, use member-style calls:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
val z = 1 + π.i
|
||||
val w = z.exp()
|
||||
val s = z.sin()
|
||||
val r = z.sqrt()
|
||||
```
|
||||
|
||||
This is deliberate. Lyng already has built-in top-level real-valued functions such as `exp(x)` and `sin(x)`, and imported modules do not currently replace those root bindings. So plain `exp(z)` is not yet the right extension mechanism for complex math.
|
||||
|
||||
## Design Scope
|
||||
|
||||
This module intentionally uses `Complex` with `Real` parts, not `Complex<T>`.
|
||||
|
||||
Reasons:
|
||||
|
||||
- the existing math runtime is `Real`-centric
|
||||
- the operator interop registry works with concrete runtime classes
|
||||
- transcendental functions (`exp`, `sin`, `ln`, `sqrt`) are defined over the `Real` math backend here
|
||||
|
||||
If Lyng later gets a more general numeric-trait or callable-overload registry, a generic algebraic `Complex<T>` can be revisited on firmer ground.
|
||||
+325
@@ -0,0 +1,325 @@
|
||||
# Decimal (`lyng.decimal`)
|
||||
|
||||
`lyng.decimal` adds an arbitrary-precision decimal type to Lyng as a normal library module.
|
||||
|
||||
Import it when you need decimal arithmetic that should not inherit `Real`'s binary floating-point behavior:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
```
|
||||
|
||||
## What `Decimal` Is For
|
||||
|
||||
Use `Decimal` when values are fundamentally decimal:
|
||||
|
||||
- money
|
||||
- human-entered quantities
|
||||
- exact decimal text
|
||||
- predictable decimal rounding
|
||||
- user-facing formatting and tests
|
||||
|
||||
Do not use it just because a number has a fractional part. `Real` is still the right type for ordinary double-precision numeric work.
|
||||
|
||||
## Creating Decimal Values
|
||||
|
||||
There are three supported conversions:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
val a = 1.d
|
||||
val b = 2.2.d
|
||||
val c = "2.2".d
|
||||
|
||||
assertEquals("1", a.toStringExpanded())
|
||||
assertEquals("2.2", b.toStringExpanded())
|
||||
assertEquals("2.2", c.toStringExpanded())
|
||||
```
|
||||
|
||||
The three forms mean different things:
|
||||
|
||||
- `1.d`: convert `Int -> Decimal`
|
||||
- `2.2.d`: convert `Real -> Decimal`
|
||||
- `"2.2".d`: parse exact decimal text
|
||||
|
||||
That distinction is intentional.
|
||||
|
||||
### `Real.d` vs `"..." .d`
|
||||
|
||||
`Real.d` preserves the current `Real` value. It does not pretend the source code was exact decimal text.
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
|
||||
assertEquals("0.3", "0.3".d.toStringExpanded())
|
||||
```
|
||||
|
||||
This follows the "minimal confusion" rule:
|
||||
|
||||
- if you start from a `Real`, you get a decimal representation of that `Real`
|
||||
- if you want exact decimal source text, use a `String`
|
||||
|
||||
## Factory Functions
|
||||
|
||||
The explicit factory methods are:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
Decimal.fromInt(10)
|
||||
Decimal.fromReal(2.5)
|
||||
Decimal.fromString("12.34")
|
||||
```
|
||||
|
||||
These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code.
|
||||
|
||||
## From Kotlin
|
||||
|
||||
If you already have an ionspin `BigDecimal` on the host side, the simplest supported way to create a Lyng `Decimal` is:
|
||||
|
||||
```kotlin
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.asFacade
|
||||
import net.sergeych.lyng.newDecimal
|
||||
|
||||
val scope = EvalSession().getScope()
|
||||
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
|
||||
```
|
||||
|
||||
Notes:
|
||||
|
||||
- `newDecimal(...)` loads `lyng.decimal` if needed
|
||||
- it returns a real Lyng `Decimal` object instance
|
||||
- this is the preferred Kotlin-side construction path when you already hold a host `BigDecimal`
|
||||
|
||||
## Core Operations
|
||||
|
||||
`Decimal` supports:
|
||||
|
||||
- `+`
|
||||
- `-`
|
||||
- `*`
|
||||
- `/`
|
||||
- `%`
|
||||
- unary `-`
|
||||
- comparison operators
|
||||
- equality operators
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("3.75", ("1.5".d + "2.25".d).toStringExpanded())
|
||||
assertEquals("1.25", ("2.5".d - "1.25".d).toStringExpanded())
|
||||
assertEquals("3.0", ("1.5".d * 2.d).toStringExpanded())
|
||||
assertEquals("0.5", (1.d / 2.d).toStringExpanded())
|
||||
assert("2.0".d > "1.5".d)
|
||||
assert("2.0".d == 2.d)
|
||||
```
|
||||
|
||||
## Interoperability With `Int` and `Real`
|
||||
|
||||
The decimal module registers mixed-operand operator bridges so both sides read naturally:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(3.d, 1 + 2.d)
|
||||
assertEquals(3.d, 2.d + 1)
|
||||
assertEquals(1.5.d, 1.d + 0.5)
|
||||
assertEquals(1.5.d, 0.5 + 1.d)
|
||||
assert(2 == 2.d)
|
||||
assert(3 > 2.d)
|
||||
```
|
||||
|
||||
Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + Decimal` and `Real + Decimal`.
|
||||
|
||||
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
|
||||
|
||||
## String Representation
|
||||
|
||||
Use `toStringExpanded()` when you want plain decimal output without scientific notation:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("12.34", "12.34".d.toStringExpanded())
|
||||
```
|
||||
|
||||
This is the recommended representation for:
|
||||
|
||||
- tests
|
||||
- user-visible diagnostics
|
||||
- decimal formatting checks
|
||||
|
||||
## Conversions Back To Built-ins
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(2, "2.9".d.toInt())
|
||||
assertEquals(2.9, "2.9".d.toReal())
|
||||
```
|
||||
|
||||
Use `toReal()` only when you are willing to return to binary floating-point semantics.
|
||||
|
||||
## Non-Finite Checks
|
||||
|
||||
`Decimal` values are always finite, so these helpers exist for API symmetry with `Real` and always return `false`:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(false, "2.9".d.isInfinite())
|
||||
assertEquals(false, "2.9".d.isNaN())
|
||||
```
|
||||
|
||||
## Division Context
|
||||
|
||||
Division is the operation where precision and rounding matter most.
|
||||
|
||||
By default, decimal division uses:
|
||||
|
||||
- precision: `34` significant digits
|
||||
- rounding: `HalfEven`
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
|
||||
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
|
||||
```
|
||||
|
||||
## `withDecimalContext(...)`
|
||||
|
||||
Use `withDecimalContext(...)` to override decimal division rules inside a block:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(
|
||||
"0.3333333333",
|
||||
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
|
||||
)
|
||||
```
|
||||
|
||||
You can also pass an explicit context object:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
val ctx = DecimalContext(6, DecimalRounding.HalfAwayFromZero)
|
||||
assertEquals("0.666667", withDecimalContext(ctx) { ("2".d / 3.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
The context is dynamic and local to the block. After the block exits, the previous context is restored.
|
||||
|
||||
## Rounding Modes
|
||||
|
||||
Available rounding modes:
|
||||
|
||||
- `HalfEven`
|
||||
- `HalfAwayFromZero`
|
||||
- `HalfTowardsZero`
|
||||
- `Ceiling`
|
||||
- `Floor`
|
||||
- `AwayFromZero`
|
||||
- `TowardsZero`
|
||||
|
||||
Tie example at precision `2`:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("0.13", withDecimalContext(2, DecimalRounding.Ceiling) { (1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("0.12", withDecimalContext(2, DecimalRounding.Floor) { (1.d / 8.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
Negative values follow the same named policy in the obvious direction:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
## Recommended Usage Rules
|
||||
|
||||
## Decimal With Stdlib Math Functions
|
||||
|
||||
Core math helpers such as `abs`, `floor`, `ceil`, `round`, `sin`, `exp`, `ln`, `sqrt`, `log10`, `log2`, and `pow`
|
||||
now also accept `Decimal`.
|
||||
|
||||
Current behavior is intentionally split:
|
||||
|
||||
- exact decimal implementation:
|
||||
- `abs(x)`
|
||||
- `floor(x)`
|
||||
- `ceil(x)`
|
||||
- `round(x)`
|
||||
- `pow(x, y)` when `x` is `Decimal` and `y` is an integral exponent
|
||||
- temporary bridge through `Real`:
|
||||
- `sin`, `cos`, `tan`
|
||||
- `asin`, `acos`, `atan`
|
||||
- `sinh`, `cosh`, `tanh`
|
||||
- `asinh`, `acosh`, `atanh`
|
||||
- `exp`, `ln`, `log10`, `log2`
|
||||
- `sqrt`
|
||||
- `pow` for the remaining non-integral decimal exponent cases
|
||||
|
||||
The temporary bridge is:
|
||||
|
||||
```lyng
|
||||
Decimal -> Real -> host math -> Decimal
|
||||
```
|
||||
|
||||
This is a compatibility step, not the long-term design. Native decimal implementations will replace these bridge-based
|
||||
paths over time.
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("2.5", (abs("-2.5".d) as Decimal).toStringExpanded())
|
||||
assertEquals("2", (floor("2.9".d) as Decimal).toStringExpanded())
|
||||
|
||||
// Temporary Real bridge:
|
||||
assertEquals((exp(1.25) as Real).d.toStringExpanded(), (exp("1.25".d) as Decimal).toStringExpanded())
|
||||
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), (sqrt("2".d) as Decimal).toStringExpanded())
|
||||
```
|
||||
|
||||
If you care about exact decimal source text:
|
||||
|
||||
```lyng
|
||||
"12.34".d
|
||||
```
|
||||
|
||||
If you intentionally convert an existing binary floating-point value:
|
||||
|
||||
```lyng
|
||||
someReal.d
|
||||
```
|
||||
|
||||
If you want local control over division:
|
||||
|
||||
```lyng
|
||||
withDecimalContext(precision, rounding) { ... }
|
||||
```
|
||||
|
||||
If you want custom mixed operators for your own type, follow the same pattern as Decimal and use the operator registry:
|
||||
|
||||
- define the operators on your own class
|
||||
- choose a common class
|
||||
- register mixed operand bridges
|
||||
|
||||
See [OperatorInterop.md](OperatorInterop.md).
|
||||
@@ -30,6 +30,13 @@ There is a shortcut for the last:
|
||||
|
||||
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
|
||||
|
||||
The language also allows multi-selector indexing syntax such as `value[i, j]`, but `List` itself uses a single selector only:
|
||||
|
||||
- `list[index]` for one element
|
||||
- `list[range]` for a slice copy
|
||||
|
||||
Multi-selector indexing is intended for custom indexers such as `Matrix`.
|
||||
|
||||
## Concatenation
|
||||
|
||||
You can concatenate lists or iterable objects:
|
||||
|
||||
+192
@@ -0,0 +1,192 @@
|
||||
# Matrix (`lyng.matrix`)
|
||||
|
||||
`lyng.matrix` adds dense immutable `Matrix` and `Vector` types for linear algebra.
|
||||
|
||||
Import it when you need matrix or vector arithmetic:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
```
|
||||
|
||||
## Construction
|
||||
|
||||
Create vectors from a flat list and matrices from nested row lists:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val v: Vector = vector([1, 2, 3])
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals([1.0, 2.0, 3.0], v.toList())
|
||||
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], m.toList())
|
||||
```
|
||||
|
||||
Factory methods are also available:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val z: Vector = Vector.zeros(3)
|
||||
val i: Matrix = Matrix.identity(3)
|
||||
val m: Matrix = Matrix.zeros(2, 4)
|
||||
```
|
||||
|
||||
All elements are standard double-precision numeric values internally.
|
||||
|
||||
## Shapes
|
||||
|
||||
Matrices may have any rectangular geometry:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals(2, a.rows)
|
||||
assertEquals(3, a.cols)
|
||||
assertEquals([2, 3], a.shape)
|
||||
assertEquals(false, a.isSquare)
|
||||
```
|
||||
|
||||
Vectors expose:
|
||||
|
||||
- `size`
|
||||
- `length` as an alias of `size`
|
||||
|
||||
## Matrix Operations
|
||||
|
||||
Supported matrix operations:
|
||||
|
||||
- `+` and `-` for element-wise matrix arithmetic
|
||||
- `*` for matrix-matrix product
|
||||
- `*` and `/` by a scalar
|
||||
- `transpose()`
|
||||
- `trace()`
|
||||
- `rank()`
|
||||
- `determinant()`
|
||||
- `inverse()`
|
||||
- `solve(rhs)` for `Vector` or `Matrix` right-hand sides
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
|
||||
val product: Matrix = a * b
|
||||
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
|
||||
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], a.transpose().toList())
|
||||
```
|
||||
|
||||
Inverse and solve:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[4, 7], [2, 6]])
|
||||
val rhs: Vector = vector([1, 0])
|
||||
|
||||
val inv: Matrix = a.inverse()
|
||||
val x: Vector = a.solve(rhs)
|
||||
|
||||
assert(abs(a.determinant() - 10.0) < 1e-9)
|
||||
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
|
||||
assert(abs(x.get(0) - 0.6) < 1e-9)
|
||||
```
|
||||
|
||||
## Vector Operations
|
||||
|
||||
Supported vector operations:
|
||||
|
||||
- `+` and `-`
|
||||
- scalar `*` and `/`
|
||||
- `dot(other)`
|
||||
- `norm()`
|
||||
- `normalize()`
|
||||
- `cross(other)` for 3D vectors
|
||||
- `outer(other)` producing a matrix
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Vector = vector([1, 2, 3])
|
||||
val b: Vector = vector([2, 0, 0])
|
||||
|
||||
assertEquals(2.0, a.dot(b))
|
||||
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], a.normalize().toList())
|
||||
```
|
||||
|
||||
## Indexing and Slicing
|
||||
|
||||
`Matrix` supports both method-style indexing and bracket syntax.
|
||||
|
||||
Scalar access:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals(6.0, m.get(1, 2))
|
||||
assertEquals(6.0, m[1, 2])
|
||||
```
|
||||
|
||||
Bracket indexing accepts two selectors: `[row, col]`.
|
||||
Each selector may be either:
|
||||
|
||||
- an `Int`
|
||||
- a `Range`
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
|
||||
|
||||
assertEquals(7.0, m[1, 2])
|
||||
val columnSlice: Matrix = m[0..2, 2]
|
||||
val topLeft: Matrix = m[0..1, 0..1]
|
||||
val tail: Matrix = m[1.., 1..]
|
||||
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
|
||||
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
|
||||
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
|
||||
```
|
||||
|
||||
Shape rules:
|
||||
|
||||
- `m[Int, Int]` returns a `Real`
|
||||
- `m[Range, Int]` returns an `Nx1` `Matrix`
|
||||
- `m[Int, Range]` returns a `1xM` `Matrix`
|
||||
- `m[Range, Range]` returns a submatrix
|
||||
|
||||
Open-ended ranges are supported:
|
||||
|
||||
- `m[..1, ..1]`
|
||||
- `m[1.., 1..]`
|
||||
- `m[.., 2]`
|
||||
|
||||
Stepped ranges are not supported in matrix slicing.
|
||||
|
||||
Slices currently return new matrices, not views.
|
||||
|
||||
## Rows and Columns
|
||||
|
||||
If you want plain lists instead of a sliced matrix:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals([4.0, 5.0, 6.0], a.row(1))
|
||||
assertEquals([2.0, 5.0], a.column(1))
|
||||
```
|
||||
|
||||
## Backend Notes
|
||||
|
||||
The matrix module uses a platform-specific backend where available and falls back to pure Kotlin where needed.
|
||||
|
||||
The public Lyng API stays the same across platforms.
|
||||
+18
-2
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
|
||||
assertEquals("buzz", x[0])
|
||||
>>> void
|
||||
|
||||
If you want dynamic to function like an array, create a [feature
|
||||
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
|
||||
Multiple selectors are packed into one list index object:
|
||||
|
||||
val x = dynamic {
|
||||
get {
|
||||
if( it == [1, 2] ) "hit"
|
||||
else null
|
||||
}
|
||||
}
|
||||
assertEquals("hit", x[1, 2])
|
||||
>>> void
|
||||
|
||||
So:
|
||||
|
||||
- `x[i]` passes `i`
|
||||
- `x[i, j]` passes `[i, j]`
|
||||
- `x[i, j, k]` passes `[i, j, k]`
|
||||
|
||||
This is the same rule used by Kotlin-backed `getAt` / `putAt` indexers in embedding.
|
||||
|
||||
# Theory
|
||||
|
||||
|
||||
@@ -0,0 +1,309 @@
|
||||
# Operator Interop Registry
|
||||
|
||||
`lyng.operators` provides a runtime registry for mixed-class binary operators.
|
||||
|
||||
Import it when you want expressions such as:
|
||||
|
||||
- `1 + MyType(...)`
|
||||
- `2 < MyType(...)`
|
||||
- `3 == MyType(...)`
|
||||
|
||||
to work without modifying the built-in `Int` or `Real` classes.
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
```
|
||||
|
||||
## Why This Exists
|
||||
|
||||
If your class defines:
|
||||
|
||||
```lyng
|
||||
class Amount(val value: Int) {
|
||||
fun plus(other: Amount) = Amount(value + other.value)
|
||||
}
|
||||
```
|
||||
|
||||
then:
|
||||
|
||||
```lyng
|
||||
Amount(1) + Amount(2)
|
||||
```
|
||||
|
||||
works, because the left operand already knows how to add another `Amount`.
|
||||
|
||||
But:
|
||||
|
||||
```lyng
|
||||
1 + Amount(2)
|
||||
```
|
||||
|
||||
does not naturally work, because `Int` has not been rewritten to know about `Amount`.
|
||||
|
||||
The operator interop registry solves exactly that problem.
|
||||
|
||||
## Mental Model
|
||||
|
||||
Registration describes a mixed pair:
|
||||
|
||||
- left class `L`
|
||||
- right class `R`
|
||||
- common class `C`
|
||||
|
||||
When Lyng sees `L op R`, it:
|
||||
|
||||
1. converts `L -> C`
|
||||
2. converts `R -> C`
|
||||
3. evaluates the operator as `C op C`
|
||||
|
||||
So the registry is a bridge, not a separate arithmetic engine.
|
||||
|
||||
## API
|
||||
|
||||
```lyng
|
||||
OperatorInterop.register(
|
||||
leftClass,
|
||||
rightClass,
|
||||
commonClass,
|
||||
operators,
|
||||
leftToCommon,
|
||||
rightToCommon
|
||||
)
|
||||
```
|
||||
|
||||
Parameters:
|
||||
|
||||
- `leftClass`: original left operand class
|
||||
- `rightClass`: original right operand class
|
||||
- `commonClass`: class that will actually execute the operator methods
|
||||
- `operators`: list of operators enabled for this pair
|
||||
- `leftToCommon`: conversion from left operand to common class
|
||||
- `rightToCommon`: conversion from right operand to common class
|
||||
|
||||
## Supported Operators
|
||||
|
||||
`BinaryOperator` values:
|
||||
|
||||
- `Plus`
|
||||
- `Minus`
|
||||
- `Mul`
|
||||
- `Div`
|
||||
- `Mod`
|
||||
- `Compare`
|
||||
- `Equals`
|
||||
|
||||
Meaning:
|
||||
|
||||
- `Compare` enables `<`, `<=`, `>`, `>=`, and `<=>`
|
||||
- `Equals` enables `==` and `!=`
|
||||
|
||||
## Minimal Working Example
|
||||
|
||||
```lyng
|
||||
package test.decimalbox
|
||||
import lyng.operators
|
||||
|
||||
class DecimalBox(val value: Int) {
|
||||
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
fun minus(other: DecimalBox) = DecimalBox(value - other.value)
|
||||
fun mul(other: DecimalBox) = DecimalBox(value * other.value)
|
||||
fun div(other: DecimalBox) = DecimalBox(value / other.value)
|
||||
fun mod(other: DecimalBox) = DecimalBox(value % other.value)
|
||||
fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
DecimalBox,
|
||||
DecimalBox,
|
||||
[
|
||||
BinaryOperator.Plus,
|
||||
BinaryOperator.Minus,
|
||||
BinaryOperator.Mul,
|
||||
BinaryOperator.Div,
|
||||
BinaryOperator.Mod,
|
||||
BinaryOperator.Compare,
|
||||
BinaryOperator.Equals
|
||||
],
|
||||
{ x: Int -> DecimalBox(x) },
|
||||
{ x: DecimalBox -> x }
|
||||
)
|
||||
```
|
||||
|
||||
Then:
|
||||
|
||||
```lyng
|
||||
import test.decimalbox
|
||||
|
||||
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 3 - DecimalBox(2))
|
||||
assertEquals(DecimalBox(8), 4 * DecimalBox(2))
|
||||
assertEquals(DecimalBox(4), 8 / DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 7 % DecimalBox(2))
|
||||
assert(1 < DecimalBox(2))
|
||||
assert(2 <= DecimalBox(2))
|
||||
assert(3 > DecimalBox(2))
|
||||
assert(2 == DecimalBox(2))
|
||||
assert(2 != DecimalBox(3))
|
||||
```
|
||||
|
||||
## How Decimal Uses It
|
||||
|
||||
`lyng.decimal` uses this same mechanism so that:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
1 + 2.d
|
||||
0.5 + 1.d
|
||||
2 == 2.d
|
||||
3 > 2.d
|
||||
```
|
||||
|
||||
work naturally even though `Int` and `Real` themselves were not edited to know `Decimal`.
|
||||
|
||||
The shape is:
|
||||
|
||||
- `leftClass = Int` or `Real`
|
||||
- `rightClass = Decimal`
|
||||
- `commonClass = Decimal`
|
||||
- convert built-ins into `Decimal`
|
||||
- leave `Decimal` values unchanged
|
||||
|
||||
## Step-By-Step Pattern For Your Own Type
|
||||
|
||||
### 1. Pick the common class
|
||||
|
||||
Choose one class that will be the actual arithmetic domain.
|
||||
|
||||
For numeric-like types, that is usually your own class:
|
||||
|
||||
```lyng
|
||||
class Rational(...)
|
||||
```
|
||||
|
||||
### 2. Implement operators on that class
|
||||
|
||||
The common class should define the operations you plan to register.
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
class Rational(val num: Int, val den: Int) {
|
||||
fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
|
||||
fun minus(other: Rational) = Rational(num * other.den - other.num * den, den * other.den)
|
||||
fun mul(other: Rational) = Rational(num * other.num, den * other.den)
|
||||
fun div(other: Rational) = Rational(num * other.den, den * other.num)
|
||||
fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
|
||||
|
||||
static fun fromInt(value: Int) = Rational(value, 1)
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Register the mixed pair
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
Rational,
|
||||
Rational,
|
||||
[
|
||||
BinaryOperator.Plus,
|
||||
BinaryOperator.Minus,
|
||||
BinaryOperator.Mul,
|
||||
BinaryOperator.Div,
|
||||
BinaryOperator.Compare,
|
||||
BinaryOperator.Equals
|
||||
],
|
||||
{ x: Int -> Rational.fromInt(x) },
|
||||
{ x: Rational -> x }
|
||||
)
|
||||
```
|
||||
|
||||
### 4. Use it
|
||||
|
||||
```lyng
|
||||
assertEquals(Rational(3, 2), 1 + Rational(1, 2))
|
||||
assert(Rational(3, 2) == Rational(3, 2))
|
||||
assert(2 > Rational(3, 2))
|
||||
```
|
||||
|
||||
## Registering More Than One Built-in Type
|
||||
|
||||
If you want both `Int + MyType` and `Real + MyType`, register both pairs explicitly:
|
||||
|
||||
```lyng
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
MyType,
|
||||
MyType,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> MyType.fromInt(x) },
|
||||
{ x: MyType -> x }
|
||||
)
|
||||
|
||||
OperatorInterop.register(
|
||||
Real,
|
||||
MyType,
|
||||
MyType,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Real -> MyType.fromReal(x) },
|
||||
{ x: MyType -> x }
|
||||
)
|
||||
```
|
||||
|
||||
Each mixed pair is independent.
|
||||
|
||||
## Pure Lyng Registration
|
||||
|
||||
This mechanism is intentionally useful from pure Lyng code, not only from Kotlin-backed modules.
|
||||
|
||||
That means you can:
|
||||
|
||||
- declare a class in Lyng
|
||||
- define its operators in Lyng
|
||||
- register mixed operand bridges in Lyng
|
||||
|
||||
without touching compiler internals.
|
||||
|
||||
## Where To Register
|
||||
|
||||
Register once during module initialization.
|
||||
|
||||
Top-level module code is a good place:
|
||||
|
||||
```lyng
|
||||
package my.rational
|
||||
import lyng.operators
|
||||
|
||||
class Rational(...)
|
||||
|
||||
OperatorInterop.register(...)
|
||||
```
|
||||
|
||||
That keeps registration close to the type declaration and makes importing the module enough to activate the interop.
|
||||
|
||||
## What Registration Does Not Do
|
||||
|
||||
The registry does not:
|
||||
|
||||
- invent operators your common class does not implement
|
||||
- change the original `Int`, `Real`, or other built-ins
|
||||
- automatically cover every class pair
|
||||
- replace normal method overload resolution when the left-hand class already knows what to do
|
||||
|
||||
It only teaches Lyng how to bridge a specific mixed pair into a common class for the listed operators.
|
||||
|
||||
## Recommended Design Rules
|
||||
|
||||
If you want interop to feel natural:
|
||||
|
||||
- choose one obvious common class
|
||||
- make conversions explicit and unsurprising
|
||||
- implement `compareTo` if you want ordering operators
|
||||
- register `Equals` whenever mixed equality should work
|
||||
- keep the registered operator list minimal and accurate
|
||||
|
||||
For decimal-like semantics, also read [Decimal.md](Decimal.md).
|
||||
@@ -19,6 +19,8 @@ you can use it's class to ensure type:
|
||||
|-----------------|-------------------------------------------------------------|------|
|
||||
| `.roundToInt()` | round to nearest int like round(x) | Int |
|
||||
| `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int |
|
||||
| `.isInfinite()` | true when the value is `Infinity` or `-Infinity` | Bool |
|
||||
| `.isNaN()` | true when the value is `NaN` | Bool |
|
||||
| `.clamp(range)` | clamp value within range boundaries | Real |
|
||||
| | | |
|
||||
| | | |
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# Lyng Language Reference for AI Agents (Current Compiler State)
|
||||
|
||||
[//]: # (excludeFromIndex)
|
||||
|
||||
Purpose: dense, implementation-first reference for generating valid Lyng code.
|
||||
|
||||
Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,Token,Compiler,Script,TypeDecl}.kt`, `lynglib/stdlib/lyng/root.lyng`, tests in `lynglib/src/commonTest` and `lynglib/src/jvmTest`.
|
||||
@@ -17,6 +19,14 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
|
||||
- Supported escapes: `\n`, `\r`, `\t`, `\"`, `\\`, `\uXXXX` (4 hex digits).
|
||||
- Unicode escapes use exactly 4 hex digits (for example: `"\u0416"` -> `Ж`).
|
||||
- Unknown `\x` escapes in strings are preserved literally as two characters (`\` and `x`).
|
||||
- String interpolation is supported:
|
||||
- identifier form: `"$name"`
|
||||
- expression form: `"${expr}"`
|
||||
- escaped dollar: `"\$"` and `"$$"` both produce literal `$`.
|
||||
- `\\$x` means backslash + interpolated `x`.
|
||||
- Per-file opt-out is supported via leading comment directive:
|
||||
- `// feature: interpolation: off`
|
||||
- with this directive, `$...` stays literal text.
|
||||
- Numbers: `Int` (`123`, `1_000`), `Real` (`1.2`, `1e3`), hex (`0xFF`).
|
||||
- Char: `'a'`, escaped chars supported.
|
||||
- Supported escapes: `\n`, `\r`, `\t`, `\'`, `\\`, `\uXXXX` (4 hex digits).
|
||||
@@ -74,11 +84,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
|
||||
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
|
||||
- Null-safe family:
|
||||
- member access: `?.`
|
||||
- safe index: `?[i]`
|
||||
- safe index: `?[i]`, `?[i, j]`
|
||||
- safe invoke: `?(...)`
|
||||
- safe block invoke: `?{ ... }`
|
||||
- elvis: `?:` and `??`.
|
||||
- Increment/decrement: prefix and postfix `++`, `--`.
|
||||
- Indexing syntax:
|
||||
- single selector: `a[i]`
|
||||
- multiple selectors: `a[i, j, k]`
|
||||
- language-level indexing with multiple selectors is passed to `getAt`/`putAt` as one list-like index object, not as multiple method arguments.
|
||||
- example: `m[0..2, 2]`.
|
||||
|
||||
## 5. Declarations
|
||||
- Variables:
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# AI notes: avoid Kotlin/Wasm invalid IR with suspend lambdas
|
||||
|
||||
[//]: # (excludeFromIndex)
|
||||
|
||||
## Do
|
||||
- Prefer explicit `object : Statement()` with `override suspend fun execute(...)` when building compiler statements.
|
||||
- Keep `Statement` objects non-lambda, especially in compiler hot paths like parsing/var declarations.
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# Lyng Stdlib Reference for AI Agents (Compact)
|
||||
|
||||
[//]: # (excludeFromIndex)
|
||||
|
||||
Purpose: fast overview of what is available by default and what must be imported.
|
||||
|
||||
Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/stdlib/lyng/root.lyng`, `lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/observable_lyng.kt`.
|
||||
@@ -14,7 +16,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
|
||||
- Preconditions: `require`, `check`.
|
||||
- Async/concurrency: `launch`, `yield`, `flow`, `delay`.
|
||||
- `Deferred.cancel()` cancels an active task.
|
||||
- `Deferred.await()` throws `CancellationException` if that task was cancelled.
|
||||
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
|
||||
- These helpers also accept `lyng.decimal.Decimal`.
|
||||
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
|
||||
- Temporary Decimal path for the rest: convert `Decimal -> Real`, compute, then convert back to `Decimal`.
|
||||
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
|
||||
|
||||
## 3. Core Global Constants/Types
|
||||
- Values: `Unset`, `π`.
|
||||
@@ -22,13 +30,14 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
|
||||
- Random: singleton `Random` and class `SeededRandom`.
|
||||
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
|
||||
- Async exception: `CancellationException`.
|
||||
- Delegation types: `Delegate`, `DelegateContext`.
|
||||
- Regex types: `Regex`, `RegexMatch`.
|
||||
- Also present: `Math.PI` namespace constant.
|
||||
|
||||
## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
|
||||
### 4.1 Extern class declarations
|
||||
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
|
||||
- Exceptions/delegation base: `Exception`, `CancellationException`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
|
||||
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
|
||||
- Host iterator bridge: `KotlinIterator<T>`.
|
||||
- Random APIs: `extern object Random`, `extern class SeededRandom`.
|
||||
@@ -56,6 +65,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
## 5. Additional Built-in Modules (import explicitly)
|
||||
- `import lyng.observable`
|
||||
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
|
||||
- `import lyng.decimal`
|
||||
- `Decimal`, `DecimalContext`, `DecimalRounding`, `withDecimalContext(...)`.
|
||||
- Kotlin host helper: `ScopeFacade.newDecimal(BigDecimal)` wraps an ionspin host decimal as a Lyng `Decimal`.
|
||||
- `import lyng.complex`
|
||||
- `Complex`, `complex(re, im)`, `cis(angle)`, and numeric embedding extensions such as `2.i` / `3.re`.
|
||||
- `import lyng.matrix`
|
||||
- `Matrix`, `Vector`, `matrix(rows)`, `vector(values)`, dense linear algebra, inversion, solving, and matrix slicing with `m[row, col]`.
|
||||
- `import lyng.buffer`
|
||||
- `Buffer`, `MutableBuffer`.
|
||||
- `import lyng.serialization`
|
||||
@@ -68,8 +84,11 @@ Requires installing `lyngio` into the import manager from host code.
|
||||
- `import lyng.io.fs` (filesystem `Path` API)
|
||||
- `import lyng.io.process` (process execution API)
|
||||
- `import lyng.io.console` (console capabilities, geometry, ANSI/output, events)
|
||||
- `import lyng.io.http` (HTTP/HTTPS client API)
|
||||
- `import lyng.io.ws` (WebSocket client API; currently supported on JVM, capability-gated elsewhere)
|
||||
- `import lyng.io.net` (TCP/UDP transport API; currently supported on JVM, capability-gated elsewhere)
|
||||
|
||||
## 7. AI Generation Tips
|
||||
- Assume `lyng.stdlib` APIs exist in regular script contexts.
|
||||
- For platform-sensitive code (`fs`, `process`, `console`), gate assumptions and mention required module install.
|
||||
- For platform-sensitive code (`fs`, `process`, `console`, `http`, `ws`, `net`), gate assumptions and mention required module install.
|
||||
- Prefer extension-method style (`items.filter { ... }`) and standard scope helpers (`let`/`also`/`apply`/`run`).
|
||||
@@ -0,0 +1,11 @@
|
||||
# Some resources to download
|
||||
|
||||
## Lync CLI tool
|
||||
|
||||
- [lyng-linuxX64.zip](/distributables/lyng-linuxX64.zip) CLI tool for linuxX64: nodependencies, small monolith executable binary.
|
||||
|
||||
## IDE plugins
|
||||
|
||||
- [lyng-textmate.zip](../../lyng/distributables/lyng-textmate.zip) Texmate-compatible bundle with syntax coloring (could be outdated)
|
||||
|
||||
- [lyng-idea-0.0.5-SNAPSHOT.zip](/distributables/lyng-idea-0.0.5-SNAPSHOT.zip) - plugin for IntelliJ-compatible IDE
|
||||
+180
-27
@@ -1,5 +1,7 @@
|
||||
# Embedding Lyng in your Kotlin project
|
||||
|
||||
[//]: # (topMenu)
|
||||
|
||||
Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows, step by step, how to:
|
||||
|
||||
- add Lyng to your build
|
||||
@@ -36,21 +38,60 @@ dependencies {
|
||||
|
||||
If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs).
|
||||
|
||||
### 2) Create a runtime (Scope) and execute scripts
|
||||
### 2) Preferred runtime: `EvalSession`
|
||||
|
||||
The easiest way to get a ready‑to‑use scope with standard packages is via `Script.newScope()`.
|
||||
For host applications, prefer `EvalSession` as the main way to run scripts.
|
||||
It owns one reusable Lyng scope, serializes `eval(...)` calls, and governs coroutines started from Lyng `launch { ... }`.
|
||||
|
||||
Main entrypoints:
|
||||
|
||||
- `session.eval(code)` / `session.eval(source)`
|
||||
- `session.getScope()` when you need low-level binding APIs
|
||||
- `session.cancel()` to cancel active session-owned coroutines
|
||||
- `session.join()` to wait for active session-owned coroutines
|
||||
|
||||
```kotlin
|
||||
fun main() = kotlinx.coroutines.runBlocking {
|
||||
val session = EvalSession()
|
||||
|
||||
// Evaluate a one‑liner
|
||||
val result = session.eval("1 + 2 * 3")
|
||||
println("Lyng result: $result") // ObjReal/ObjInt etc.
|
||||
|
||||
// Optional lifecycle management
|
||||
session.join()
|
||||
}
|
||||
```
|
||||
|
||||
The session creates its underlying scope lazily. If you need raw low-level APIs, get the scope explicitly:
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
```
|
||||
|
||||
Use `cancel()` / `join()` to govern async work started by scripts:
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
session.eval("""launch { delay(1000); println("done") }""")
|
||||
session.cancel()
|
||||
session.join()
|
||||
```
|
||||
|
||||
### 2.1) Low-level runtime: `Scope`
|
||||
|
||||
Use `Scope` directly when you intentionally want lower-level control.
|
||||
|
||||
```kotlin
|
||||
fun main() = kotlinx.coroutines.runBlocking {
|
||||
val scope = Script.newScope() // suspends on first init
|
||||
|
||||
// Evaluate a one‑liner
|
||||
val result = scope.eval("1 + 2 * 3")
|
||||
println("Lyng result: $result") // ObjReal/ObjInt etc.
|
||||
println("Lyng result: $result")
|
||||
}
|
||||
```
|
||||
|
||||
You can also pre‑compile a script and execute it multiple times:
|
||||
You can also pre‑compile a script and execute it multiple times on the same scope:
|
||||
|
||||
```kotlin
|
||||
val script = Compiler.compile("""
|
||||
@@ -63,7 +104,8 @@ val run1 = script.execute(scope)
|
||||
val run2 = script.execute(scope)
|
||||
```
|
||||
|
||||
`Scope.eval("...")` is a shortcut that compiles and executes on the given scope.
|
||||
`Scope.eval("...")` is the low-level shortcut that compiles and executes on the given scope.
|
||||
For most embedding use cases, prefer `session.eval("...")`.
|
||||
|
||||
### 3) Preferred: bind extern globals from Kotlin
|
||||
|
||||
@@ -72,11 +114,21 @@ For module-level APIs, the default workflow is:
|
||||
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
|
||||
2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
|
||||
|
||||
This is also the recommended way to expose a Kotlin-backed value that should behave like a true
|
||||
Lyng global variable/property. If you need `x` to read/write through Kotlin on every access, use
|
||||
`extern var` / `extern val` plus `bindGlobalVar(...)`.
|
||||
|
||||
Do not use `addConst(...)` for this case: `addConst(...)` installs a value, not a Kotlin-backed
|
||||
property accessor. It is appropriate for fixed values and objects, but not for a global that should
|
||||
delegate reads/writes back into Kotlin state.
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
val im = Script.defaultImportManager.copy()
|
||||
im.addPackage("my.api") { module ->
|
||||
module.eval("""
|
||||
@@ -117,6 +169,12 @@ assertEquals("changed", globalProp)
|
||||
assertEquals("1.0.0", globalVersion)
|
||||
```
|
||||
|
||||
Minimal rule of thumb:
|
||||
|
||||
- use `bindGlobalFun(...)` for global functions
|
||||
- use `bindGlobalVar(...)` for Kotlin-backed global variables/properties
|
||||
- use `addConst(...)` only for fixed values/objects that do not need getter/setter behavior
|
||||
|
||||
For custom argument handling and full runtime access:
|
||||
|
||||
```kotlin
|
||||
@@ -135,6 +193,9 @@ binder.bindGlobalFunRaw("echoRaw") { _, args ->
|
||||
Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3.
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
|
||||
// A function returning value
|
||||
scope.addFn<ObjInt>("inc") {
|
||||
val x = args.firstAndOnly() as ObjInt
|
||||
@@ -153,7 +214,7 @@ scope.addVoidFn("log") {
|
||||
// }
|
||||
|
||||
// Call them from Lyng
|
||||
scope.eval("val y = inc(41); log('Answer:', y)")
|
||||
session.eval("val y = inc(41); log('Answer:', y)")
|
||||
```
|
||||
|
||||
You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`.
|
||||
@@ -169,11 +230,79 @@ Scope-backed Kotlin lambdas receive a `ScopeFacade` (not a full `Scope`). For mi
|
||||
|
||||
If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
|
||||
|
||||
### 4.5) Indexers from Kotlin: `getAt` and `putAt`
|
||||
|
||||
Lyng bracket syntax is dispatched through `getAt` and `putAt`.
|
||||
|
||||
That means:
|
||||
|
||||
- `x[i]` calls `getAt(index)`
|
||||
- `x[i] = value` calls `putAt(index, value)` or `setAt(index, value)`
|
||||
- field-like `x["name"]` also uses the same index path unless you expose a real field/property
|
||||
|
||||
For Kotlin-backed classes, bind indexers as ordinary methods named `getAt` and `putAt`:
|
||||
|
||||
```kotlin
|
||||
moduleScope.eval("""
|
||||
extern class Grid {
|
||||
override fun getAt(index: List<Int>): Int
|
||||
override fun putAt(index: List<Int>, value: Int): void
|
||||
}
|
||||
""".trimIndent())
|
||||
|
||||
moduleScope.bind("Grid") {
|
||||
init { _ -> data = IntArray(4) }
|
||||
|
||||
addFun("getAt") {
|
||||
val index = args.requiredArg<ObjList>(0)
|
||||
val row = (index.list[0] as ObjInt).value.toInt()
|
||||
val col = (index.list[1] as ObjInt).value.toInt()
|
||||
val data = (thisObj as ObjInstance).data as IntArray
|
||||
ObjInt.of(data[row * 2 + col].toLong())
|
||||
}
|
||||
|
||||
addFun("putAt") {
|
||||
val index = args.requiredArg<ObjList>(0)
|
||||
val value = args.requiredArg<ObjInt>(1).value.toInt()
|
||||
val row = (index.list[0] as ObjInt).value.toInt()
|
||||
val col = (index.list[1] as ObjInt).value.toInt()
|
||||
val data = (thisObj as ObjInstance).data as IntArray
|
||||
data[row * 2 + col] = value
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Usage from Lyng:
|
||||
|
||||
```lyng
|
||||
val g = Grid()
|
||||
g[0, 1] = 42
|
||||
assertEquals(42, g[0, 1])
|
||||
```
|
||||
|
||||
Important rule: multiple selectors inside brackets are packed into one index object.
|
||||
So:
|
||||
|
||||
- `x[i]` passes `i`
|
||||
- `x[i, j]` passes a `List` containing `[i, j]`
|
||||
- `x[i, j, k]` passes `[i, j, k]`
|
||||
|
||||
This applies equally to:
|
||||
|
||||
- Kotlin-backed classes
|
||||
- Lyng classes overriding `getAt`
|
||||
- `dynamic { get { ... } set { ... } }`
|
||||
|
||||
If you want multi-axis slicing semantics, decode that list yourself in `getAt`.
|
||||
|
||||
### 5) Add Kotlin‑backed fields
|
||||
|
||||
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
val myClass = ObjClass("MyClass")
|
||||
|
||||
// Add a read-only field (constant)
|
||||
@@ -201,6 +330,8 @@ println(instance.count) // -> 5
|
||||
Properties in Lyng are pure accessors (getters and setters) and do not have automatic backing fields. You can add them to a class using `addProperty`.
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
val myClass = ObjClass("MyClass")
|
||||
var internalValue: Long = 10
|
||||
|
||||
@@ -367,8 +498,9 @@ For Kotlin code that needs dynamic access to Lyng variables, functions, or membe
|
||||
It provides explicit, cached handles and predictable lookup rules.
|
||||
|
||||
```kotlin
|
||||
val scope = Script.newScope()
|
||||
scope.eval("""
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
session.eval("""
|
||||
val x = 40
|
||||
fun add(a, b) = a + b
|
||||
class Box { var value = 1 }
|
||||
@@ -383,7 +515,7 @@ val x = resolver.resolveVal("x").get(scope)
|
||||
val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2)))
|
||||
|
||||
// Member access
|
||||
val box = scope.eval("Box()")
|
||||
val box = session.eval("Box()")
|
||||
val valueHandle = resolver.resolveMemberVar(box, "value")
|
||||
valueHandle.set(scope, ObjInt(10))
|
||||
val value = valueHandle.get(scope)
|
||||
@@ -394,12 +526,14 @@ val value = valueHandle.get(scope)
|
||||
The simplest approach: evaluate an expression that yields the value and convert it.
|
||||
|
||||
```kotlin
|
||||
val kotlinAnswer = scope.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int)
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
val kotlinAnswer = session.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int)
|
||||
|
||||
// After scripts manipulate your vars:
|
||||
scope.addOrUpdateItem("name", ObjString("Lyng"))
|
||||
scope.eval("name = name + ' rocks!'")
|
||||
val kotlinName = scope.eval("name").toKotlin(scope) // -> "Lyng rocks!"
|
||||
session.eval("name = name + ' rocks!'")
|
||||
val kotlinName = session.eval("name").toKotlin(scope) // -> "Lyng rocks!"
|
||||
```
|
||||
|
||||
Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently.
|
||||
@@ -412,16 +546,20 @@ There are two convenient patterns.
|
||||
|
||||
```kotlin
|
||||
// Suppose Lyng defines: fun add(a, b) = a + b
|
||||
scope.eval("fun add(a, b) = a + b")
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
session.eval("fun add(a, b) = a + b")
|
||||
|
||||
val sum = scope.eval("add(20, 22)").toKotlin(scope) // -> 42
|
||||
val sum = session.eval("add(20, 22)").toKotlin(scope) // -> 42
|
||||
```
|
||||
|
||||
2) Call a Lyng function by name via a prepared call scope:
|
||||
|
||||
```kotlin
|
||||
// Ensure the function exists in the scope
|
||||
scope.eval("fun add(a, b) = a + b")
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
session.eval("fun add(a, b) = a + b")
|
||||
|
||||
// Look up the function object
|
||||
val addFn = scope.get("add")!!.value as Statement
|
||||
@@ -452,7 +590,8 @@ Register a Kotlin‑built package:
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
|
||||
val scope = Script.newScope()
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
|
||||
// Access the import manager behind this scope
|
||||
val im: ImportManager = scope.importManager
|
||||
@@ -462,25 +601,33 @@ im.addPackage("my.tools") { module: ModuleScope ->
|
||||
module.eval(
|
||||
"""
|
||||
extern val version: String
|
||||
extern var status: String
|
||||
extern fun triple(x: Int): Int
|
||||
""".trimIndent()
|
||||
)
|
||||
val binder = module.globalBinder()
|
||||
var status = "ready"
|
||||
binder.bindGlobalVar(
|
||||
name = "version",
|
||||
get = { "1.0" }
|
||||
)
|
||||
binder.bindGlobalVar(
|
||||
name = "status",
|
||||
get = { status },
|
||||
set = { status = it }
|
||||
)
|
||||
binder.bindGlobalFun1<Int>("triple") { x ->
|
||||
ObjInt.of((x * 3).toLong())
|
||||
}
|
||||
}
|
||||
|
||||
// Use it from Lyng
|
||||
scope.eval("""
|
||||
session.eval("""
|
||||
import my.tools.*
|
||||
val v = triple(14)
|
||||
status = "busy"
|
||||
""")
|
||||
val v = scope.eval("v").toKotlin(scope) // -> 42
|
||||
val v = session.eval("v").toKotlin(scope) // -> 42
|
||||
```
|
||||
|
||||
Register a package from Lyng source text:
|
||||
@@ -494,24 +641,27 @@ val pkgText = """
|
||||
|
||||
scope.importManager.addTextPackages(pkgText)
|
||||
|
||||
scope.eval("""
|
||||
session.eval("""
|
||||
import math.extra.*
|
||||
val s = sqr(12)
|
||||
""")
|
||||
val s = scope.eval("s").toKotlin(scope) // -> 144
|
||||
val s = session.eval("s").toKotlin(scope) // -> 144
|
||||
```
|
||||
|
||||
You can also register from parsed `Source` instances via `addSourcePackages(source)`.
|
||||
|
||||
### 10) Executing from files, security, and isolation
|
||||
|
||||
- To run code from a file, read it and pass to `scope.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`.
|
||||
- To run code from a file, read it and pass to `session.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`.
|
||||
- `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments.
|
||||
- For isolation, create fresh modules/scopes via `Scope.new()` or `Script.newScope()` when you need a clean environment per request.
|
||||
- For isolation, prefer a fresh `EvalSession()` per request. Use `Scope.new()` / `Script.newScope()` when you specifically need low-level raw scopes or modules.
|
||||
|
||||
```kotlin
|
||||
// Fresh module based on the default manager, without the standard prelude
|
||||
val isolated = net.sergeych.lyng.Scope.new()
|
||||
// Preferred per-request runtime:
|
||||
val isolatedSession = EvalSession()
|
||||
|
||||
// Low-level fresh module based on the default manager, without the standard prelude:
|
||||
val isolatedScope = net.sergeych.lyng.Scope.new()
|
||||
```
|
||||
|
||||
### 11) Tips and troubleshooting
|
||||
@@ -546,8 +696,11 @@ To simplify handling these objects from Kotlin, several extension methods are pr
|
||||
You can serialize Lyng exception objects using `Lynon` to transmit them across boundaries and then rethrow them.
|
||||
|
||||
```kotlin
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
|
||||
try {
|
||||
scope.eval("throw MyUserException(404, \"Not Found\")")
|
||||
session.eval("throw MyUserException(404, \"Not Found\")")
|
||||
} catch (e: ExecutionError) {
|
||||
// 1. Serialize the Lyng exception object
|
||||
val encoded: UByteArray = lynonEncodeAny(scope, e.errorObject)
|
||||
|
||||
@@ -122,7 +122,8 @@ data class TestJson2(
|
||||
|
||||
@Test
|
||||
fun deserializeMapWithJsonTest() = runTest {
|
||||
val x = eval("""
|
||||
val session = EvalSession()
|
||||
val x = session.eval("""
|
||||
import lyng.serialization
|
||||
{ value: 1, inner: { "foo": 1, "bar": 2 }}
|
||||
""".trimIndent()).decodeSerializable<TestJson2>()
|
||||
@@ -143,7 +144,8 @@ data class TestJson3(
|
||||
)
|
||||
@Test
|
||||
fun deserializeAnyMapWithJsonTest() = runTest {
|
||||
val x = eval("""
|
||||
val session = EvalSession()
|
||||
val x = session.eval("""
|
||||
import lyng.serialization
|
||||
{ value: 12, inner: { "foo": 1, "bar": "two" }}
|
||||
""".trimIndent()).decodeSerializable<TestJson3>()
|
||||
@@ -175,4 +177,3 @@ on [Instant](time.md), see `Instant.truncateTo...` functions.
|
||||
|
||||
(3)
|
||||
: Map keys must be strings, map values may be any objects serializable to Json.
|
||||
|
||||
+18
-6
@@ -9,12 +9,13 @@
|
||||
#### Install in host
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.io.console.createConsoleModule
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
|
||||
suspend fun initScope() {
|
||||
val scope = Script.newScope()
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
|
||||
}
|
||||
```
|
||||
@@ -40,7 +41,18 @@ Console.setCursorVisible(true)
|
||||
Console.flush()
|
||||
```
|
||||
|
||||
Interactive sample script in this repo:
|
||||
#### Tetris sample
|
||||
|
||||
The repository includes a full interactive Tetris sample that demonstrates:
|
||||
|
||||
- alternate screen rendering
|
||||
- raw keyboard input
|
||||
- resize handling
|
||||
- typed console events
|
||||
|
||||

|
||||
|
||||
Run it from the project root in a real TTY:
|
||||
|
||||
```bash
|
||||
lyng examples/tetris_console.lyng
|
||||
@@ -50,7 +62,7 @@ lyng examples/tetris_console.lyng
|
||||
|
||||
- `Console.isSupported(): Bool` — whether console control is available on this platform/runtime.
|
||||
- `Console.isTty(): Bool` — whether output is attached to a TTY.
|
||||
- `Console.ansiLevel(): String` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`.
|
||||
- `Console.ansiLevel(): ConsoleAnsiLevel` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`.
|
||||
- `Console.geometry(): ConsoleGeometry?` — `{columns, rows}` as typed object or `null`.
|
||||
- `Console.details(): ConsoleDetails` — consolidated capability object.
|
||||
- `Console.write(text: String)` — writes to console output.
|
||||
@@ -81,9 +93,9 @@ launch {
|
||||
|
||||
#### Event format
|
||||
|
||||
`Console.events()` emits `ConsoleEvent` with at least:
|
||||
`Console.events()` emits `ConsoleEvent` with:
|
||||
|
||||
- `type: String` — `resize`, `keydown`, `keyup`
|
||||
- `type: ConsoleEventType` — `UNKNOWN`, `RESIZE`, `KEY_DOWN`, `KEY_UP`
|
||||
|
||||
Additional fields:
|
||||
|
||||
|
||||
+12
-8
@@ -39,23 +39,27 @@ This brings in:
|
||||
|
||||
---
|
||||
|
||||
#### Install the module into a Lyng Scope
|
||||
#### Install the module into a Lyng session
|
||||
|
||||
The filesystem module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using the installer. You can customize access control via `FsAccessPolicy`.
|
||||
The filesystem module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `FsAccessPolicy`.
|
||||
|
||||
Kotlin (host) bootstrap example:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.io.fs.createFs
|
||||
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
||||
|
||||
val scope: Scope = Scope.new()
|
||||
val installed: Boolean = createFs(PermitAllAccessPolicy, scope)
|
||||
// installed == true on first registration in this ImportManager, false on repeats
|
||||
suspend fun bootstrapFs() {
|
||||
val session = EvalSession()
|
||||
val scope: Scope = session.getScope()
|
||||
val installed: Boolean = createFs(PermitAllAccessPolicy, scope)
|
||||
// installed == true on first registration in this ImportManager, false on repeats
|
||||
|
||||
// In scripts (or via scope.eval), import the module to use its symbols:
|
||||
scope.eval("import lyng.io.fs")
|
||||
// In scripts (or via session.eval), import the module to use its symbols:
|
||||
session.eval("import lyng.io.fs")
|
||||
}
|
||||
```
|
||||
|
||||
You can install with a custom policy too (see Access policy below).
|
||||
@@ -185,7 +189,7 @@ val denyWrites = object : FsAccessPolicy {
|
||||
}
|
||||
|
||||
createFs(denyWrites, scope)
|
||||
scope.eval("import lyng.io.fs")
|
||||
session.eval("import lyng.io.fs")
|
||||
```
|
||||
|
||||
Composite operations like `copy` and `move` are checked as a set of primitives (e.g., `OpenRead(src)` + `Delete(dst)` if overwriting + `CreateFile(dst)` + `OpenWrite(dst)`).
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
### lyng.io.http — HTTP/HTTPS client for Lyng scripts
|
||||
|
||||
This module provides a compact HTTP client API for Lyng scripts. It is implemented in `lyngio` and backed by Ktor on supported runtimes.
|
||||
|
||||
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
|
||||
|
||||
---
|
||||
|
||||
#### Add the library to your project (Gradle)
|
||||
|
||||
If you use this repository as a multi-module project, add a dependency on `:lyngio`:
|
||||
|
||||
```kotlin
|
||||
dependencies {
|
||||
implementation("net.sergeych:lyngio:0.0.1-SNAPSHOT")
|
||||
}
|
||||
```
|
||||
|
||||
For external projects, ensure you also use the Lyng Maven repository described in `lyng.io.fs`.
|
||||
|
||||
---
|
||||
|
||||
#### Install the module into a Lyng session
|
||||
|
||||
The HTTP module is not installed automatically. Install it into the session scope and provide a policy.
|
||||
|
||||
Kotlin (host) bootstrap example:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.io.http.createHttpModule
|
||||
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
|
||||
|
||||
suspend fun bootstrapHttp() {
|
||||
val session = EvalSession()
|
||||
val scope: Scope = session.getScope()
|
||||
createHttpModule(PermitAllHttpAccessPolicy, scope)
|
||||
session.eval("import lyng.io.http")
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Using from Lyng scripts
|
||||
|
||||
Simple GET:
|
||||
|
||||
import lyng.io.http
|
||||
|
||||
val r = Http.get(HTTP_TEST_URL + "/hello")
|
||||
[r.status, r.text()]
|
||||
>>> [200,hello from test]
|
||||
|
||||
Headers and response header access:
|
||||
|
||||
import lyng.io.http
|
||||
|
||||
val r = Http.get(HTTP_TEST_URL + "/headers")
|
||||
[r.headers["X-Reply"], r.headers.getAll("X-Reply").size, r.text()]
|
||||
>>> [one,2,header demo]
|
||||
|
||||
Programmatic request object:
|
||||
|
||||
import lyng.io.http
|
||||
|
||||
val q = HttpRequest()
|
||||
q.method = "POST"
|
||||
q.url = HTTP_TEST_URL + "/echo"
|
||||
q.headers = Map("Content-Type" => "text/plain")
|
||||
q.bodyText = "ping"
|
||||
|
||||
val r = Http.request(q)
|
||||
r.text()
|
||||
>>> "POST:ping"
|
||||
|
||||
HTTPS GET:
|
||||
|
||||
import lyng.io.http
|
||||
|
||||
val r = Http.get(HTTPS_TEST_URL + "/hello")
|
||||
[r.status, r.text()]
|
||||
>>> [200,hello from test]
|
||||
|
||||
---
|
||||
|
||||
#### API reference
|
||||
|
||||
##### `Http` (static methods)
|
||||
|
||||
- `isSupported(): Bool` — Whether HTTP client support is available on the current runtime.
|
||||
- `request(req: HttpRequest): HttpResponse` — Execute a request described by a mutable request object.
|
||||
- `get(url: String, headers...): HttpResponse` — Convenience GET request.
|
||||
- `post(url: String, bodyText: String = "", contentType: String? = null, headers...): HttpResponse` — Convenience text POST request.
|
||||
- `postBytes(url: String, body: Buffer, contentType: String? = null, headers...): HttpResponse` — Convenience binary POST request.
|
||||
|
||||
For convenience methods, `headers...` accepts:
|
||||
|
||||
- `MapEntry`, e.g. `"Accept" => "text/plain"`
|
||||
- 2-item lists, e.g. `["Accept", "text/plain"]`
|
||||
|
||||
##### `HttpRequest`
|
||||
|
||||
- `method: String`
|
||||
- `url: String`
|
||||
- `headers: Map<String, String>`
|
||||
- `bodyText: String?`
|
||||
- `bodyBytes: Buffer?`
|
||||
- `timeoutMillis: Int?`
|
||||
|
||||
Only one of `bodyText` and `bodyBytes` should be set.
|
||||
|
||||
##### `HttpResponse`
|
||||
|
||||
- `status: Int`
|
||||
- `statusText: String`
|
||||
- `headers: HttpHeaders`
|
||||
- `text(): String`
|
||||
- `bytes(): Buffer`
|
||||
|
||||
Response body decoding is cached inside the response object.
|
||||
|
||||
##### `HttpHeaders`
|
||||
|
||||
`HttpHeaders` behaves like `Map<String, String>` for the first value of each header name and additionally exposes:
|
||||
|
||||
- `get(name: String): String?`
|
||||
- `getAll(name: String): List<String>`
|
||||
- `names(): List<String>`
|
||||
|
||||
Header lookup is case-insensitive.
|
||||
|
||||
---
|
||||
|
||||
#### Security policy
|
||||
|
||||
The module uses `HttpAccessPolicy` to authorize requests before they are sent.
|
||||
|
||||
- `HttpAccessPolicy` — interface for custom policies
|
||||
- `PermitAllHttpAccessPolicy` — allows all requests
|
||||
- `HttpAccessOp.Request(method, url)` — operation checked by the policy
|
||||
|
||||
Example restricted policy in Kotlin:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.http.security.HttpAccessOp
|
||||
import net.sergeych.lyngio.http.security.HttpAccessPolicy
|
||||
|
||||
val allowLocalOnly = object : HttpAccessPolicy {
|
||||
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
|
||||
when (op) {
|
||||
is HttpAccessOp.Request ->
|
||||
if (
|
||||
op.url.startsWith("http://127.0.0.1:") ||
|
||||
op.url.startsWith("https://127.0.0.1:") ||
|
||||
op.url.startsWith("http://localhost:") ||
|
||||
op.url.startsWith("https://localhost:")
|
||||
)
|
||||
AccessDecision(Decision.Allow)
|
||||
else
|
||||
AccessDecision(Decision.Deny, "only local HTTP/HTTPS requests are allowed")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Platform support
|
||||
|
||||
- **JVM:** supported
|
||||
- **Android:** supported via the Ktor CIO client backend
|
||||
- **JS:** supported via the Ktor JS client backend
|
||||
- **Linux native:** supported via the Ktor Curl client backend
|
||||
- **Windows native:** supported via the Ktor WinHttp client backend
|
||||
- **Apple native:** supported via the Ktor Darwin client backend
|
||||
- **Other targets:** may report unsupported; use `Http.isSupported()` before relying on it
|
||||
@@ -0,0 +1,169 @@
|
||||
### lyng.io.net — TCP and UDP sockets for Lyng scripts
|
||||
|
||||
This module provides minimal raw transport networking for Lyng scripts. It is implemented in `lyngio` and backed by Ktor sockets on the JVM and Linux Native, and by Node networking APIs on JS/Node runtimes.
|
||||
|
||||
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
|
||||
|
||||
---
|
||||
|
||||
#### Install the module into a Lyng session
|
||||
|
||||
Kotlin (host) bootstrap example:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.io.net.createNetModule
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
|
||||
suspend fun bootstrapNet() {
|
||||
val session = EvalSession()
|
||||
val scope: Scope = session.getScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
session.eval("import lyng.io.net")
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Using from Lyng scripts
|
||||
|
||||
Capability checks and address resolution:
|
||||
|
||||
import lyng.io.net
|
||||
|
||||
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
|
||||
[Net.isSupported(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
|
||||
>>> [true,127.0.0.1:4040,true,true]
|
||||
|
||||
TCP client connect, write, read, and close:
|
||||
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", NET_TEST_TCP_PORT)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
socket.close()
|
||||
reply
|
||||
>>> "reply:ping"
|
||||
|
||||
Lyng TCP server socket operations with `tcpListen()` and `accept()`:
|
||||
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.tcpListen(0, "127.0.0.1")
|
||||
val port = server.localAddress().port
|
||||
val accepted = launch {
|
||||
val client = server.accept()
|
||||
val line = (client.read(4) as Buffer).decodeUtf8()
|
||||
client.writeUtf8("echo:" + line)
|
||||
client.flush()
|
||||
client.close()
|
||||
server.close()
|
||||
line
|
||||
}
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", port)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
socket.close()
|
||||
[accepted.await(), reply]
|
||||
>>> [ping,echo:ping]
|
||||
|
||||
UDP bind, send, receive, and inspect sender address:
|
||||
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.udpBind(0, "127.0.0.1")
|
||||
val client = Net.udpBind(0, "127.0.0.1")
|
||||
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
|
||||
val d = server.receive()
|
||||
client.close()
|
||||
server.close()
|
||||
[d.data.decodeUtf8(), d.address.port > 0]
|
||||
>>> [ping,true]
|
||||
|
||||
---
|
||||
|
||||
#### API reference
|
||||
|
||||
##### `Net` (static methods)
|
||||
|
||||
- `isSupported(): Bool` — Whether any raw networking support is available.
|
||||
- `isTcpAvailable(): Bool` — Whether outbound TCP sockets are available.
|
||||
- `isTcpServerAvailable(): Bool` — Whether listening TCP server sockets are available.
|
||||
- `isUdpAvailable(): Bool` — Whether UDP datagram sockets are available.
|
||||
- `resolve(host: String, port: Int): List<SocketAddress>` — Resolve a host and port into concrete addresses.
|
||||
- `tcpConnect(host: String, port: Int, timeoutMillis: Int? = null, noDelay: Bool = true): TcpSocket` — Open an outbound TCP socket.
|
||||
- `tcpListen(port: Int, host: String? = null, backlog: Int = 128, reuseAddress: Bool = true): TcpServer` — Start a listening TCP server socket.
|
||||
- `udpBind(port: Int = 0, host: String? = null, reuseAddress: Bool = true): UdpSocket` — Bind a UDP socket.
|
||||
|
||||
##### `SocketAddress`
|
||||
|
||||
- `host: String`
|
||||
- `port: Int`
|
||||
- `ipVersion: IpVersion`
|
||||
- `resolved: Bool`
|
||||
- `toString(): String`
|
||||
|
||||
##### `TcpSocket`
|
||||
|
||||
- `isOpen(): Bool`
|
||||
- `localAddress(): SocketAddress`
|
||||
- `remoteAddress(): SocketAddress`
|
||||
- `read(maxBytes: Int = 65536): Buffer?`
|
||||
- `readLine(): String?`
|
||||
- `write(data: Buffer): void`
|
||||
- `writeUtf8(text: String): void`
|
||||
- `flush(): void`
|
||||
- `close(): void`
|
||||
|
||||
##### `TcpServer`
|
||||
|
||||
- `isOpen(): Bool`
|
||||
- `localAddress(): SocketAddress`
|
||||
- `accept(): TcpSocket`
|
||||
- `close(): void`
|
||||
|
||||
##### `UdpSocket`
|
||||
|
||||
- `isOpen(): Bool`
|
||||
- `localAddress(): SocketAddress`
|
||||
- `receive(maxBytes: Int = 65536): Datagram?`
|
||||
- `send(data: Buffer, host: String, port: Int): void`
|
||||
- `close(): void`
|
||||
|
||||
##### `Datagram`
|
||||
|
||||
- `data: Buffer`
|
||||
- `address: SocketAddress`
|
||||
|
||||
---
|
||||
|
||||
#### Security policy
|
||||
|
||||
The module uses `NetAccessPolicy` to authorize network operations before they are executed.
|
||||
|
||||
- `NetAccessPolicy` — interface for custom policies
|
||||
- `PermitAllNetAccessPolicy` — allows all network operations
|
||||
- `NetAccessOp.Resolve(host, port)`
|
||||
- `NetAccessOp.TcpConnect(host, port)`
|
||||
- `NetAccessOp.TcpListen(host, port, backlog)`
|
||||
- `NetAccessOp.UdpBind(host, port)`
|
||||
|
||||
---
|
||||
|
||||
#### Platform support
|
||||
|
||||
- **JVM:** supported
|
||||
- **Android:** supported via the Ktor CIO and Ktor sockets backends
|
||||
- **JS/Node:** supported for `resolve`, TCP client/server, and UDP
|
||||
- **JS/browser:** unsupported; capability checks report unavailable
|
||||
- **Linux Native:** supported via Ktor sockets
|
||||
- **Apple Native:** enabled via the shared native Ktor sockets backend; compile-verified, runtime not yet host-verified
|
||||
- **Other native targets:** currently report unsupported; use capability checks before relying on raw sockets
|
||||
+10
-8
@@ -20,24 +20,26 @@ For external projects, ensure you have the appropriate Maven repository configur
|
||||
|
||||
---
|
||||
|
||||
#### Install the module into a Lyng Scope
|
||||
#### Install the module into a Lyng session
|
||||
|
||||
The process module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using `createProcessModule`. You can customize access control via `ProcessAccessPolicy`.
|
||||
The process module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `ProcessAccessPolicy`.
|
||||
|
||||
Kotlin (host) bootstrap example:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.io.process.createProcessModule
|
||||
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
|
||||
|
||||
// ... inside a suspend function or runBlocking
|
||||
val scope: Scope = Script.newScope()
|
||||
createProcessModule(PermitAllProcessAccessPolicy, scope)
|
||||
suspend fun bootstrapProcess() {
|
||||
val session = EvalSession()
|
||||
val scope: Scope = session.getScope()
|
||||
createProcessModule(PermitAllProcessAccessPolicy, scope)
|
||||
|
||||
// In scripts (or via scope.eval), import the module:
|
||||
scope.eval("import lyng.io.process")
|
||||
// In scripts (or via session.eval), import the module:
|
||||
session.eval("import lyng.io.process")
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
### lyng.io.ws — WebSocket client for Lyng scripts
|
||||
|
||||
This module provides a compact WebSocket client API for Lyng scripts. It is implemented in `lyngio` and currently backed by Ktor WebSockets on the JVM.
|
||||
|
||||
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
|
||||
|
||||
---
|
||||
|
||||
#### Install the module into a Lyng session
|
||||
|
||||
Kotlin (host) bootstrap example:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.io.ws.createWsModule
|
||||
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
|
||||
|
||||
suspend fun bootstrapWs() {
|
||||
val session = EvalSession()
|
||||
val scope: Scope = session.getScope()
|
||||
createWsModule(PermitAllWsAccessPolicy, scope)
|
||||
session.eval("import lyng.io.ws")
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Using from Lyng scripts
|
||||
|
||||
Simple text message exchange:
|
||||
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect(WS_TEST_URL)
|
||||
ws.sendText("ping")
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[ws.url() == WS_TEST_URL, m.isText, m.text]
|
||||
>>> [true,true,echo:ping]
|
||||
|
||||
Binary message exchange:
|
||||
|
||||
import lyng.buffer
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect(WS_TEST_BINARY_URL)
|
||||
ws.sendBytes(Buffer(9, 8, 7))
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[m.isText, (m.data as Buffer).hex]
|
||||
>>> [false,010203090807]
|
||||
|
||||
Secure websocket (`wss`) exchange:
|
||||
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect(WSS_TEST_URL)
|
||||
ws.sendText("ping")
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[ws.url() == WSS_TEST_URL, m.text]
|
||||
>>> [true,secure:ping]
|
||||
|
||||
---
|
||||
|
||||
#### API reference
|
||||
|
||||
##### `Ws` (static methods)
|
||||
|
||||
- `isSupported(): Bool` — Whether WebSocket client support is available on the current runtime.
|
||||
- `connect(url: String, headers...): WsSession` — Open a client websocket session.
|
||||
|
||||
`headers...` accepts:
|
||||
|
||||
- `MapEntry`, e.g. `"Authorization" => "Bearer x"`
|
||||
- 2-item lists, e.g. `["Authorization", "Bearer x"]`
|
||||
|
||||
##### `WsSession`
|
||||
|
||||
- `isOpen(): Bool`
|
||||
- `url(): String`
|
||||
- `sendText(text: String): void`
|
||||
- `sendBytes(data: Buffer): void`
|
||||
- `receive(): WsMessage?`
|
||||
- `close(code: Int = 1000, reason: String = ""): void`
|
||||
|
||||
`receive()` returns `null` after a clean close.
|
||||
|
||||
##### `WsMessage`
|
||||
|
||||
- `isText: Bool`
|
||||
- `text: String?`
|
||||
- `data: Buffer?`
|
||||
|
||||
Text messages populate `text`; binary messages populate `data`.
|
||||
|
||||
---
|
||||
|
||||
#### Security policy
|
||||
|
||||
The module uses `WsAccessPolicy` to authorize websocket operations.
|
||||
|
||||
- `WsAccessPolicy` — interface for custom policies
|
||||
- `PermitAllWsAccessPolicy` — allows all websocket operations
|
||||
- `WsAccessOp.Connect(url)`
|
||||
- `WsAccessOp.Send(url, bytes, isText)`
|
||||
- `WsAccessOp.Receive(url)`
|
||||
|
||||
Example restricted policy in Kotlin:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.ws.security.WsAccessOp
|
||||
import net.sergeych.lyngio.ws.security.WsAccessPolicy
|
||||
|
||||
val allowLocalOnly = object : WsAccessPolicy {
|
||||
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
|
||||
when (op) {
|
||||
is WsAccessOp.Connect ->
|
||||
if (
|
||||
op.url.startsWith("ws://127.0.0.1:") ||
|
||||
op.url.startsWith("wss://127.0.0.1:") ||
|
||||
op.url.startsWith("ws://localhost:") ||
|
||||
op.url.startsWith("wss://localhost:")
|
||||
)
|
||||
AccessDecision(Decision.Allow)
|
||||
else
|
||||
AccessDecision(Decision.Deny, "only local ws/wss connections are allowed")
|
||||
|
||||
else -> AccessDecision(Decision.Allow)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
#### Platform support
|
||||
|
||||
- **JVM:** supported
|
||||
- **Android:** supported via the Ktor CIO websocket client backend
|
||||
- **JS:** supported via the Ktor JS websocket client backend
|
||||
- **Linux native:** supported via the Ktor Curl websocket client backend
|
||||
- **Windows native:** supported via the Ktor WinHttp websocket client backend
|
||||
- **Apple native:** supported via the Ktor Darwin websocket client backend
|
||||
- **Other targets:** may report unsupported; use `Ws.isSupported()` before relying on websocket client access
|
||||
+43
-11
@@ -13,6 +13,9 @@
|
||||
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
|
||||
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
|
||||
- **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events.
|
||||
- **[lyng.io.http](lyng.io.http.md):** HTTP/HTTPS client access. Provides `Http`, `HttpRequest`, `HttpResponse`, and `HttpHeaders`.
|
||||
- **[lyng.io.ws](lyng.io.ws.md):** WebSocket client access. Provides `Ws`, `WsSession`, and `WsMessage`.
|
||||
- **[lyng.io.net](lyng.io.net.md):** Transport networking. Provides `Net`, `TcpSocket`, `TcpServer`, `UdpSocket`, and `SocketAddress`.
|
||||
|
||||
---
|
||||
|
||||
@@ -37,31 +40,47 @@ dependencies {
|
||||
To use `lyngio` modules in your scripts, you must install them into your Lyng scope and provide a security policy.
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.io.fs.createFs
|
||||
import net.sergeych.lyng.io.process.createProcessModule
|
||||
import net.sergeych.lyng.io.console.createConsoleModule
|
||||
import net.sergeych.lyng.io.http.createHttpModule
|
||||
import net.sergeych.lyng.io.net.createNetModule
|
||||
import net.sergeych.lyng.io.ws.createWsModule
|
||||
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
||||
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
|
||||
|
||||
suspend fun runMyScript() {
|
||||
val scope = Script.newScope()
|
||||
val session = EvalSession()
|
||||
val scope = session.getScope()
|
||||
|
||||
// Install modules with policies
|
||||
createFs(PermitAllAccessPolicy, scope)
|
||||
createProcessModule(PermitAllProcessAccessPolicy, scope)
|
||||
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
|
||||
createHttpModule(PermitAllHttpAccessPolicy, scope)
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
createWsModule(PermitAllWsAccessPolicy, scope)
|
||||
|
||||
// Now scripts can import them
|
||||
scope.eval("""
|
||||
session.eval("""
|
||||
import lyng.io.fs
|
||||
import lyng.io.process
|
||||
import lyng.io.console
|
||||
import lyng.io.http
|
||||
import lyng.io.net
|
||||
import lyng.io.ws
|
||||
|
||||
println("Working dir: " + Path(".").readUtf8())
|
||||
println("OS: " + Platform.details().name)
|
||||
println("TTY: " + Console.isTty())
|
||||
println("HTTP available: " + Http.isSupported())
|
||||
println("TCP available: " + Net.isTcpAvailable())
|
||||
println("WS available: " + Ws.isSupported())
|
||||
""")
|
||||
}
|
||||
```
|
||||
@@ -75,21 +94,34 @@ suspend fun runMyScript() {
|
||||
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
|
||||
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
|
||||
- **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching.
|
||||
- **HTTP Security:** Implement `HttpAccessPolicy` to restrict which requests scripts may send.
|
||||
- **Transport Security:** Implement `NetAccessPolicy` to restrict DNS resolution and TCP/UDP socket operations.
|
||||
- **WebSocket Security:** Implement `WsAccessPolicy` to restrict websocket connects and message flow.
|
||||
|
||||
For more details, see the specific module documentation:
|
||||
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
|
||||
- [Process Security Details](lyng.io.process.md#security-policy)
|
||||
- [Console Module Details](lyng.io.console.md)
|
||||
- [HTTP Module Details](lyng.io.http.md)
|
||||
- [Transport Networking Details](lyng.io.net.md)
|
||||
- [WebSocket Module Details](lyng.io.ws.md)
|
||||
|
||||
---
|
||||
|
||||
#### Platform Support Overview
|
||||
|
||||
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| **JVM** | ✅ | ✅ | ✅ (baseline) |
|
||||
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
|
||||
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
|
||||
| **Android** | ✅ | ❌ | ❌ |
|
||||
| **NodeJS** | ✅ | ❌ | ❌ |
|
||||
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
|
||||
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console | lyng.io.http | lyng.io.ws | lyng.io.net |
|
||||
| :--- | :---: | :---: | :---: | :---: | :---: | :---: |
|
||||
| **JVM** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
|
||||
| **Linux Native** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
|
||||
| **Apple Native** | ✅ | ✅ | ✅ | ✅ | ✅ | ⚠️ |
|
||||
| **Windows Native** | ✅ | ❌ | ✅ | ✅ | ✅ | ❌ |
|
||||
| **Android** | ✅ | ❌ | ⚠️ | ✅ | ✅ | ✅ |
|
||||
| **JS / Node** | ✅ | ❌ | ⚠️ | ✅ | ✅ | ✅ |
|
||||
| **JS / Browser** | ✅ (in-memory) | ❌ | ⚠️ | ✅ | ✅ | ❌ |
|
||||
| **Wasm** | ✅ (in-memory) | ❌ | ⚠️ | ❌ | ❌ | ❌ |
|
||||
|
||||
Legend:
|
||||
- `✅` supported
|
||||
- `⚠️` available but environment-dependent or not fully host-verified yet
|
||||
- `❌` unsupported
|
||||
+73
-3
@@ -60,8 +60,13 @@ but:
|
||||
|
||||
## Round and range
|
||||
|
||||
The following functions return its argument if it is `Int`,
|
||||
or transformed `Real` otherwise.
|
||||
The following functions return the argument unchanged if it is `Int`.
|
||||
|
||||
For `Decimal`:
|
||||
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
|
||||
- the result stays `Decimal`
|
||||
|
||||
For `Real`, the result is a transformed `Real`.
|
||||
|
||||
| name | description |
|
||||
|----------------|--------------------------------------------------------|
|
||||
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
|
||||
|
||||
## Lyng math functions
|
||||
|
||||
Decimal note:
|
||||
- all scalar math helpers accept `Decimal`
|
||||
- `abs(x)` stays exact for `Decimal`
|
||||
- `pow(x, y)` is exact for `Decimal` when `y` is an integral exponent
|
||||
- the remaining `Decimal` cases currently use a temporary bridge:
|
||||
`Decimal -> Real -> host math -> Decimal`
|
||||
- this is temporary; native decimal implementations are planned
|
||||
|
||||
| name | meaning |
|
||||
|-----------|------------------------------------------------------|
|
||||
| sin(x) | sine |
|
||||
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
|
||||
| log10(x) | $log_{10}(x)$ |
|
||||
| pow(x, y) | ${x^y}$ |
|
||||
| sqrt(x) | $ \sqrt {x}$ |
|
||||
| abs(x) | absolute value of x. Int if x is Int, Real otherwise |
|
||||
| abs(x) | absolute value of x. Int if x is Int, Decimal if x is Decimal, Real otherwise |
|
||||
| clamp(x, range) | limit x to be inside range boundaries |
|
||||
|
||||
For example:
|
||||
@@ -104,12 +117,69 @@ For example:
|
||||
assert( abs(-1) is Int)
|
||||
assert( abs(-2.21) == 2.21 )
|
||||
|
||||
import lyng.decimal
|
||||
|
||||
// Decimal-aware math works too. Some functions are exact, some still bridge through Real temporarily:
|
||||
assert( (abs("-2.5".d) as Decimal).toStringExpanded() == "2.5" )
|
||||
assert( (floor("2.9".d) as Decimal).toStringExpanded() == "2" )
|
||||
assert( sin("0.5".d) is Decimal )
|
||||
|
||||
// clamp() limits value to the range:
|
||||
assert( clamp(15, 0..10) == 10 )
|
||||
assert( clamp(-5, 0..10) == 0 )
|
||||
assert( 5.clamp(0..10) == 5 )
|
||||
>>> void
|
||||
|
||||
## Linear algebra: `lyng.matrix`
|
||||
|
||||
For vectors and dense matrices, import `lyng.matrix`:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
```
|
||||
|
||||
It provides:
|
||||
|
||||
- `Vector`
|
||||
- `Matrix`
|
||||
- `vector(values)`
|
||||
- `matrix(rows)`
|
||||
|
||||
Core operations include:
|
||||
|
||||
- matrix addition and subtraction
|
||||
- matrix-matrix multiplication
|
||||
- matrix-vector multiplication
|
||||
- transpose
|
||||
- determinant
|
||||
- inverse
|
||||
- linear solve
|
||||
- vector dot, norm, normalize, cross, outer product
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
|
||||
val product: Matrix = a * b
|
||||
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
|
||||
```
|
||||
|
||||
Matrices also support two-axis bracket indexing and slicing:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
val sub: Matrix = m[0..1, 1..2]
|
||||
assertEquals([[2.0, 3.0], [5.0, 6.0]], sub.toList())
|
||||
```
|
||||
|
||||
See [Matrix](Matrix.md) for the full API.
|
||||
|
||||
## Random values
|
||||
|
||||
Lyng stdlib provides a global random singleton and deterministic seeded generators:
|
||||
|
||||
+16
-1
@@ -32,10 +32,25 @@ Depending on the platform, these coroutines may be executed on different CPU and
|
||||
assert(xIsCalled)
|
||||
>>> void
|
||||
|
||||
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result.
|
||||
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion, cancel it if it is no longer needed, and retrieve possible result.
|
||||
|
||||
Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
|
||||
|
||||
If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
|
||||
|
||||
var reached = false
|
||||
val work = launch {
|
||||
delay(100)
|
||||
reached = true
|
||||
"ok"
|
||||
}
|
||||
work.cancel()
|
||||
assertThrows(CancellationException) { work.await() }
|
||||
assert(work.isCancelled)
|
||||
assert(!work.isActive)
|
||||
assert(!reached)
|
||||
>>> void
|
||||
|
||||
## Synchronization: Mutex
|
||||
|
||||
Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result:
|
||||
|
||||
+6
-5
@@ -114,10 +114,12 @@ When running end‑to‑end “book” workloads or heavier benches, you can ena
|
||||
Flags are mutable at runtime, e.g.:
|
||||
|
||||
```kotlin
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val r1 = (Scope().eval(script) as ObjInt).value
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val r2 = (Scope().eval(script) as ObjInt).value
|
||||
runTest {
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val r1 = (EvalSession(Scope()).eval(script) as ObjInt).value
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val r2 = (EvalSession(Scope()).eval(script) as ObjInt).value
|
||||
}
|
||||
```
|
||||
|
||||
Reset flags at the end of a test to avoid impacting other tests.
|
||||
@@ -619,4 +621,3 @@ Reproduce
|
||||
Notes
|
||||
- Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes.
|
||||
- IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs.
|
||||
|
||||
@@ -375,6 +375,18 @@ It is rather simple, like everywhere else:
|
||||
|
||||
See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed.
|
||||
|
||||
For linear algebra, import `lyng.matrix`:
|
||||
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2], [3, 4]])
|
||||
val i: Matrix = Matrix.identity(2)
|
||||
val sum: Matrix = a + i
|
||||
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
|
||||
>>> void
|
||||
|
||||
See [Matrix](Matrix.md) for vectors, matrix multiplication, inversion, and slicing such as `m[0..2, 1]`.
|
||||
|
||||
Logical operation could be used the same
|
||||
|
||||
var x = 10
|
||||
@@ -811,6 +823,14 @@ Lists can contain any type of objects, lists too:
|
||||
|
||||
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
|
||||
|
||||
In general, bracket indexing may contain more than one selector:
|
||||
|
||||
value[i]
|
||||
value[i, j]
|
||||
|
||||
For built-in lists, strings, maps, and buffers, the selector is usually a single value such as an `Int`, `Range`, or `Regex`.
|
||||
For types with custom indexers, multiple selectors are packed into one list-like index object and passed to `getAt` / `putAt`.
|
||||
|
||||
When you want to "flatten" it to single array, you can use splat syntax:
|
||||
|
||||
[1, ...[2,3], 4]
|
||||
@@ -1573,6 +1593,52 @@ same as:
|
||||
assert(s[1] == 'a')
|
||||
>>> void
|
||||
|
||||
### String interpolation
|
||||
|
||||
Supported forms:
|
||||
|
||||
- `$name`
|
||||
- `${expr}`
|
||||
|
||||
Literal dollar forms:
|
||||
|
||||
- `\$` -> `$`
|
||||
- `$$` -> `$`
|
||||
|
||||
Example:
|
||||
|
||||
val name = "Lyng"
|
||||
assertEquals("hello, Lyng!", "hello, $name!")
|
||||
assertEquals("sum=3", "sum=${1+2}")
|
||||
assertEquals("\$name", "\$name")
|
||||
assertEquals("\$name", "$$name")
|
||||
assertEquals("\\Lyng", "\\$name")
|
||||
>>> void
|
||||
|
||||
Interpolation and `printf`-style formatting can be combined when needed:
|
||||
|
||||
val method = "transfer"
|
||||
val argc = 2
|
||||
val compact = "%s:%d"(method, argc)
|
||||
assertEquals("call=transfer:2", "call=$compact")
|
||||
assertEquals("[transfer:2] ok", "[${"%s:%d"(method, argc)}] ok")
|
||||
>>> void
|
||||
|
||||
Interpolation also works well with regex patterns. To keep a literal `$` in the
|
||||
regex, escape it in the resulting pattern:
|
||||
|
||||
val currency = "USD"
|
||||
val amount = 15
|
||||
val escapedDollar = "\\$"
|
||||
val re = Regex("^${currency}${escapedDollar}${amount}$")
|
||||
assert("USD$15" =~ re)
|
||||
assert("USD15" !~ re)
|
||||
>>> void
|
||||
|
||||
If you need old literal behavior in a file, add a leading directive comment:
|
||||
|
||||
// feature: interpolation: off
|
||||
|
||||
### Char literal escapes
|
||||
|
||||
Are the same as in string literals with little difference:
|
||||
@@ -1653,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
|
||||
assertEquals( "pult", "catapult"[ 4.. ])
|
||||
>>> void
|
||||
|
||||
The same bracket syntax is also used by imported numeric modules such as `lyng.matrix`, where indexing can be multi-axis:
|
||||
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
>>> void
|
||||
|
||||
### String operations
|
||||
|
||||
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
|
||||
|
||||
@@ -5,6 +5,120 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
|
||||
|
||||
## Language Features
|
||||
|
||||
### Matrix and Vector Module (`lyng.matrix`)
|
||||
Lyng now ships a dense linear algebra module with immutable double-precision `Matrix` and `Vector` types.
|
||||
|
||||
It provides:
|
||||
|
||||
- `matrix([[...]])` and `vector([...])`
|
||||
- matrix multiplication
|
||||
- matrix inversion
|
||||
- determinant, trace, rank
|
||||
- solving `A * x = b`
|
||||
- vector operations such as `dot`, `normalize`, `cross`, and `outer`
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[4, 7], [2, 6]])
|
||||
val inv: Matrix = a.inverse()
|
||||
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
|
||||
```
|
||||
|
||||
Matrices also support Lyng-style slicing:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
val column: Matrix = m[0..2, 2]
|
||||
val tail: Matrix = m[1.., 1..]
|
||||
assertEquals([[3.0], [6.0], [9.0]], column.toList())
|
||||
assertEquals([[5.0, 6.0], [8.0, 9.0]], tail.toList())
|
||||
```
|
||||
|
||||
See [Matrix](Matrix.md).
|
||||
|
||||
### Multiple Selectors in Bracket Indexing
|
||||
Bracket indexing now accepts more than one selector:
|
||||
|
||||
```lyng
|
||||
value[i]
|
||||
value[i, j]
|
||||
value[i, j, k]
|
||||
```
|
||||
|
||||
For custom indexers, multiple selectors are packed into one list-like index object and dispatched through `getAt` / `putAt`.
|
||||
This is the rule used by `lyng.matrix` and by embedding APIs for Kotlin-backed indexers.
|
||||
|
||||
### Decimal Arithmetic Module (`lyng.decimal`)
|
||||
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
|
||||
|
||||
It provides:
|
||||
|
||||
- `Decimal`
|
||||
- convenient `.d` conversions from `Int`, `Real`, and `String`
|
||||
- mixed arithmetic with `Int` and `Real`
|
||||
- local division precision and rounding control via `withDecimalContext(...)`
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("3", (1 + 2.d).toStringExpanded())
|
||||
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
|
||||
assertEquals("0.3", "0.3".d.toStringExpanded())
|
||||
|
||||
assertEquals(
|
||||
"0.3333333333",
|
||||
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
|
||||
)
|
||||
```
|
||||
|
||||
The distinction between `Real -> Decimal` and exact decimal parsing is explicit by design:
|
||||
|
||||
- `2.2.d` converts the current `Real` value
|
||||
- `"2.2".d` parses exact decimal text
|
||||
|
||||
See [Decimal](Decimal.md).
|
||||
|
||||
### Binary Operator Interop Registry
|
||||
Lyng now provides a general mechanism for mixed binary operators through `lyng.operators`.
|
||||
|
||||
This solves cases like:
|
||||
|
||||
- `Int + MyType`
|
||||
- `Real < MyType`
|
||||
- `Int == MyType`
|
||||
|
||||
without requiring changes to built-in classes.
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
|
||||
class DecimalBox(val value: Int) {
|
||||
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
DecimalBox,
|
||||
DecimalBox,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> DecimalBox(x) },
|
||||
{ x: DecimalBox -> x }
|
||||
)
|
||||
|
||||
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
|
||||
assert(1 < DecimalBox(2))
|
||||
assert(2 == DecimalBox(2))
|
||||
```
|
||||
|
||||
`lyng.decimal` uses this same mechanism internally to interoperate with `Int` and `Real`.
|
||||
|
||||
See [Operator Interop Registry](OperatorInterop.md).
|
||||
|
||||
### Class Properties with Accessors
|
||||
Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors.
|
||||
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/env/bin lyng
|
||||
|
||||
import lyng.io.http
|
||||
|
||||
// Step 1: download the main lynglang.com page.
|
||||
val home = Http.get("https://lynglang.com").text()
|
||||
|
||||
// Step 2: find the version-script reference in the page HTML.
|
||||
val jsRef = "src=\"([^\"]*lyng-version\\.js)\"".re.find(home)
|
||||
require(jsRef != null, "lyng-version.js reference not found on the homepage")
|
||||
|
||||
// Step 3: extract the referenced script path from the first regex capture.
|
||||
val versionJsPath = jsRef[1]
|
||||
|
||||
// Step 4: download the script that exposes `window.LYNG_VERSION`.
|
||||
val versionJs = Http.get("https://lynglang.com/" + versionJsPath).text()
|
||||
|
||||
// Step 5: pull the actual version string from the JavaScript source.
|
||||
val versionMatch = "LYNG_VERSION\\s*=\\s*\"([^\"]+)\"".re.find(versionJs)
|
||||
require(versionMatch != null, "LYNG_VERSION assignment not found")
|
||||
|
||||
// Step 6: print the discovered version for the user.
|
||||
println("Lynglang.com version: " + ((versionMatch as RegexMatch)[1]))
|
||||
@@ -0,0 +1,76 @@
|
||||
fun calculateDepth(
|
||||
T: Real,
|
||||
m: Real,
|
||||
d: Real,
|
||||
rho: Real = 1.2,
|
||||
c: Real = 340.0,
|
||||
g: Real = 9.81,
|
||||
Cd: Real = 0.5,
|
||||
eps: Real = 1e-3,
|
||||
maxIter: Int = 100
|
||||
): Real? {
|
||||
// Площадь миделя
|
||||
val r = d / 2.0
|
||||
val A = π * r * r
|
||||
|
||||
// Коэффициент сопротивления
|
||||
val k = 0.5 * Cd * rho * A
|
||||
|
||||
// Предельная скорость
|
||||
val vTerm = sqrt(m * g / k)
|
||||
|
||||
// Функция времени падения с высоты h
|
||||
fun tFall(h: Real): Real {
|
||||
// Для численной стабильности при больших h используем логарифмическую форму
|
||||
val arg = exp(g * h / (vTerm * vTerm))
|
||||
// arcosh(x) = ln(x + sqrt(x^2 - 1))
|
||||
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
|
||||
return vTerm / g * arcosh
|
||||
}
|
||||
|
||||
// Полное расчётное время
|
||||
fun Tcalc(h: Real): Real = tFall(h) + h / c
|
||||
|
||||
// Находим интервал, содержащий корень
|
||||
// Нижняя граница: глубина не может быть отрицательной
|
||||
var lo = 0.0
|
||||
// Верхняя граница: сначала попробуем оценку по свободному падению (без звука)
|
||||
var hi = 0.5 * g * T * T // максимальная глубина, если бы не было сопротивления и звука
|
||||
// Уточним hi, чтобы Tcalc(hi) было заведомо больше T
|
||||
while (Tcalc(hi) < T && hi < 1e4) {
|
||||
hi *= 2.0
|
||||
}
|
||||
// Проверка, что hi достаточно велико
|
||||
if (Tcalc(hi) < T) return null // слишком большая глубина, не укладываемся в разумное
|
||||
|
||||
// Бисекция
|
||||
var iter = 0
|
||||
var h = (lo + hi) / 2.0
|
||||
while (iter < maxIter && (hi - lo) > eps) {
|
||||
val f = Tcalc(h) - T
|
||||
if (abs(f) < eps) break
|
||||
if (f > 0) {
|
||||
hi = h
|
||||
} else {
|
||||
lo = h
|
||||
}
|
||||
h = (lo + hi) / 2.0
|
||||
iter++
|
||||
}
|
||||
|
||||
return h
|
||||
}
|
||||
|
||||
// Пример: T=12 секунд
|
||||
val T = 26.0
|
||||
val m = 1.0 // кг
|
||||
val d = 0.1 // м
|
||||
|
||||
val depth = calculateDepth(T, m, d)
|
||||
if (depth != null) {
|
||||
println("Глубина: %.2f м"(depth))
|
||||
// Для проверки выведем теоретическое время при найденной глубине
|
||||
// (можно добавить функцию для самопроверки)
|
||||
} else {
|
||||
println("Расчёт не сошёлся")
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.tcpListen(0, "127.0.0.1")
|
||||
val port = server.localAddress().port
|
||||
val accepted = launch {
|
||||
val client = server.accept()
|
||||
val line = (client.read(4) as Buffer).decodeUtf8()
|
||||
client.writeUtf8("echo:" + line)
|
||||
client.flush()
|
||||
client.close()
|
||||
server.close()
|
||||
line
|
||||
}
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", port)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
socket.close()
|
||||
println("${accepted.await()}: $reply")
|
||||
Regular → Executable
+317
-154
@@ -8,15 +8,25 @@
|
||||
* - Up arrow or W: rotate
|
||||
* - Down arrow or S: soft drop
|
||||
* - Space: hard drop
|
||||
* - Q or Escape: quit
|
||||
* - P or Escape: pause
|
||||
* - Q: quit
|
||||
|
||||
Tsted to score:
|
||||
sergeych@sergeych-XPS-17-9720:~$ ~/dev/lyng/examples/tetris_console.lyng
|
||||
Bye.
|
||||
Score: 435480
|
||||
Lines: 271
|
||||
Level: 28
|
||||
Ssergeych@sergeych-XPS-17-9720:~$
|
||||
*/
|
||||
|
||||
import lyng.io.console
|
||||
import lyng.io.fs
|
||||
|
||||
val MIN_COLS = 56
|
||||
val MIN_ROWS = 24
|
||||
val PANEL_WIDTH = 24
|
||||
val BOARD_MARGIN_ROWS = 8
|
||||
val BOARD_MARGIN_ROWS = 5
|
||||
val BOARD_MIN_W = 10
|
||||
val BOARD_MAX_W = 16
|
||||
val BOARD_MIN_H = 16
|
||||
@@ -26,9 +36,11 @@ val DROP_FRAMES_BASE = 15
|
||||
val DROP_FRAMES_MIN = 3
|
||||
val FRAME_DELAY_MS = 35
|
||||
val RESIZE_WAIT_MS = 250
|
||||
val MAX_PENDING_INPUTS = 64
|
||||
val ROTATION_KICKS = [0, -1, 1, -2, 2]
|
||||
val ANSI_ESC = "\u001b["
|
||||
val ANSI_RESET = ANSI_ESC + "0m"
|
||||
val ERROR_LOG_PATH = "/tmp/lyng_tetris_errors.log"
|
||||
val UNICODE_BLOCK = "██"
|
||||
val UNICODE_TOP_LEFT = "┌"
|
||||
val UNICODE_TOP_RIGHT = "┐"
|
||||
@@ -37,6 +49,7 @@ val UNICODE_BOTTOM_RIGHT = "┘"
|
||||
val UNICODE_HORIZONTAL = "──"
|
||||
val UNICODE_VERTICAL = "│"
|
||||
val UNICODE_DOT = "· "
|
||||
val PIECES: List<Piece> = []
|
||||
|
||||
type Cell = List<Int>
|
||||
type Rotation = List<Cell>
|
||||
@@ -64,52 +77,77 @@ class GameState(
|
||||
var level = 1
|
||||
var running = true
|
||||
var gameOver = false
|
||||
var paused = false
|
||||
}
|
||||
class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {}
|
||||
class InputBuffer {
|
||||
private val mutex: Mutex = Mutex()
|
||||
private val items: List<String> = []
|
||||
|
||||
fun push(value: String): Void {
|
||||
mutex.withLock {
|
||||
if (items.size >= MAX_PENDING_INPUTS) {
|
||||
items.removeAt(0)
|
||||
}
|
||||
items.add(value)
|
||||
}
|
||||
}
|
||||
|
||||
fun drain(): List<String> {
|
||||
val out: List<String> = []
|
||||
mutex.withLock {
|
||||
while (items.size > 0) {
|
||||
out.add(items[0])
|
||||
items.removeAt(0)
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
fun clearAndHome() {
|
||||
Console.clear()
|
||||
Console.home()
|
||||
}
|
||||
|
||||
fun logError(message: String, err: Object?): Void {
|
||||
try {
|
||||
var details = ""
|
||||
if (err != null) {
|
||||
try {
|
||||
details = ": " + err
|
||||
} catch (_: Object) {
|
||||
details = ": <error-format-failed>"
|
||||
}
|
||||
}
|
||||
Path(ERROR_LOG_PATH).appendUtf8(message + details + "\n")
|
||||
} catch (_: Object) {
|
||||
// Never let logging errors affect gameplay.
|
||||
}
|
||||
}
|
||||
|
||||
fun repeatText(s: String, n: Int): String {
|
||||
var out: String = ""
|
||||
var i = 0
|
||||
while (i < n) {
|
||||
for (i in 0..<n) {
|
||||
out += s
|
||||
i = i + 1
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fun maxInt(a: Int, b: Int): Int {
|
||||
if (a > b) a else b
|
||||
}
|
||||
|
||||
fun minInt(a: Int, b: Int): Int {
|
||||
if (a < b) a else b
|
||||
}
|
||||
|
||||
fun clampInt(v: Int, lo: Int, hi: Int): Int {
|
||||
minInt(hi, maxInt(lo, v))
|
||||
}
|
||||
fun max<T>(a: T, b: T): T = if (a > b) a else b
|
||||
|
||||
fun emptyRow(width: Int): Row {
|
||||
val r: Row = []
|
||||
var x = 0
|
||||
while (x < width) {
|
||||
for (x in 0..<width) {
|
||||
r.add(0)
|
||||
x = x + 1
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
fun createBoard(width: Int, height: Int): Board {
|
||||
val b: Board = []
|
||||
var y = 0
|
||||
while (y < height) {
|
||||
for (y in 0..<height) {
|
||||
b.add(emptyRow(width))
|
||||
y = y + 1
|
||||
}
|
||||
b
|
||||
}
|
||||
@@ -139,22 +177,30 @@ fun emptyCellText(useColor: Bool): String {
|
||||
}
|
||||
|
||||
fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): Bool {
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val cells = piece.rotations[rot]
|
||||
try {
|
||||
if (pieceId < 1 || pieceId > 7) return false
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
if (rot < 0 || rot >= piece.rotations.size) return false
|
||||
val cells = piece.rotations[rot]
|
||||
|
||||
for (cell in cells) {
|
||||
val x = px + cell[0]
|
||||
val y = py + cell[1]
|
||||
for (cell in cells) {
|
||||
val x = px + cell[0]
|
||||
val y = py + cell[1]
|
||||
|
||||
if (x < 0 || x >= boardW) return false
|
||||
if (y >= boardH) return false
|
||||
if (x < 0 || x >= boardW) return false
|
||||
if (y >= boardH) return false
|
||||
|
||||
if (y >= 0) {
|
||||
val row = board[y]
|
||||
if (row[x] != 0) return false
|
||||
if (y >= 0) {
|
||||
if (y >= board.size) return false
|
||||
val row = board[y]
|
||||
if (row == null) return false
|
||||
if (row[x] != 0) return false
|
||||
}
|
||||
}
|
||||
true
|
||||
} catch (_: Object) {
|
||||
false
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
|
||||
@@ -165,9 +211,11 @@ fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
|
||||
val x = px + cell[0]
|
||||
val y = py + cell[1]
|
||||
|
||||
if (y >= 0) {
|
||||
if (y >= 0 && y < board.size) {
|
||||
val row = board[y]
|
||||
row[x] = pieceId
|
||||
if (row != null) {
|
||||
row[x] = pieceId
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -178,23 +226,31 @@ fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int {
|
||||
var cleared = 0
|
||||
|
||||
while (y >= 0) {
|
||||
if (y >= b.size) {
|
||||
y--
|
||||
continue
|
||||
}
|
||||
val row = b[y]
|
||||
if (row == null) {
|
||||
b.removeAt(y)
|
||||
b.insertAt(0, emptyRow(boardW))
|
||||
cleared++
|
||||
continue
|
||||
}
|
||||
var full = true
|
||||
var x = 0
|
||||
while (x < boardW) {
|
||||
for (x in 0..<boardW) {
|
||||
if (row[x] == 0) {
|
||||
full = false
|
||||
break
|
||||
}
|
||||
x = x + 1
|
||||
}
|
||||
|
||||
if (full) {
|
||||
b.removeAt(y)
|
||||
b.insertAt(0, emptyRow(boardW))
|
||||
cleared = cleared + 1
|
||||
cleared++
|
||||
} else {
|
||||
y = y - 1
|
||||
y--
|
||||
}
|
||||
}
|
||||
|
||||
@@ -220,7 +276,7 @@ fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int,
|
||||
val nr = (rot + 1) % rotations
|
||||
for (kx in ROTATION_KICKS) {
|
||||
val nx = px + kx
|
||||
if (canPlace(board, boardW, boardH, pieceId, nr, nx, py)) {
|
||||
if (canPlace(board, boardW, boardH, pieceId, nr, nx, py) == true) {
|
||||
return RotateResult(true, nr, nx)
|
||||
}
|
||||
}
|
||||
@@ -230,21 +286,18 @@ fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int,
|
||||
fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
|
||||
val out: List<String> = []
|
||||
if (pieceId <= 0) {
|
||||
out.add(" ")
|
||||
out.add(" ")
|
||||
out.add(" ")
|
||||
out.add(" ")
|
||||
for (i in 0..<4) {
|
||||
out.add(" ")
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val cells = piece.rotations[0]
|
||||
|
||||
var y = 0
|
||||
while (y < 4) {
|
||||
for (y in 0..<4) {
|
||||
var line = ""
|
||||
var x = 0
|
||||
while (x < 4) {
|
||||
for (x in 0..<4) {
|
||||
var filled = false
|
||||
for (cell in cells) {
|
||||
if (cell[0] == x && cell[1] == y) {
|
||||
@@ -253,10 +306,8 @@ fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
|
||||
}
|
||||
}
|
||||
line += if (filled) blockText(pieceId, useColor) else " "
|
||||
x = x + 1
|
||||
}
|
||||
out.add(line)
|
||||
y = y + 1
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -296,52 +347,101 @@ fun render(
|
||||
panel.add("W/Up: rotate")
|
||||
panel.add("S/Down: drop")
|
||||
panel.add("Space: hard drop")
|
||||
panel.add("Q/Esc: quit")
|
||||
panel.add("P/Esc: pause")
|
||||
panel.add("Q: quit")
|
||||
|
||||
val frameLines: List<String> = []
|
||||
|
||||
var y = 0
|
||||
while (y < boardH) {
|
||||
for (y in 0..<boardH) {
|
||||
var line = UNICODE_VERTICAL
|
||||
|
||||
var x = 0
|
||||
while (x < boardW) {
|
||||
for (x in 0..<boardW) {
|
||||
val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y)
|
||||
val row = board[y]
|
||||
val b = row[x]
|
||||
val row = if (y < board.size) board[y] else null
|
||||
val b = if (row == null) 0 else row[x]
|
||||
val id = if (a > 0) a else b
|
||||
line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor)
|
||||
x = x + 1
|
||||
}
|
||||
|
||||
line += UNICODE_VERTICAL
|
||||
|
||||
val p = y
|
||||
if (p < panel.size) {
|
||||
line += " " + panel[p]
|
||||
if (y < panel.size) {
|
||||
line += " " + panel[y]
|
||||
}
|
||||
|
||||
frameLines.add(line)
|
||||
y = y + 1
|
||||
}
|
||||
|
||||
frameLines.add(bottomBorder)
|
||||
|
||||
val prev = prevFrameLines
|
||||
var i = 0
|
||||
while (i < frameLines.size) {
|
||||
for (i in 0..<frameLines.size) {
|
||||
val line = frameLines[i]
|
||||
val old = if (i < prev.size) prev[i] else null
|
||||
val old = if (i < prevFrameLines.size) prevFrameLines[i] else null
|
||||
if (old != line) {
|
||||
Console.moveTo(originRow + i, originCol)
|
||||
Console.clearLine()
|
||||
Console.write(line)
|
||||
}
|
||||
i = i + 1
|
||||
}
|
||||
frameLines
|
||||
}
|
||||
|
||||
fun fitLine(line: String, width: Int): String {
|
||||
val maxLen = if (width > 0) width else 0
|
||||
if (maxLen <= 0) return ""
|
||||
if (line.size >= maxLen) return line[..<maxLen]
|
||||
line + repeatText(" ", maxLen - line.size)
|
||||
}
|
||||
|
||||
fun renderPauseOverlay(
|
||||
originRow: Int,
|
||||
originCol: Int,
|
||||
boardW: Int,
|
||||
boardH: Int,
|
||||
): Void {
|
||||
val contentWidth = boardW * 2 + 2 + 3 + PANEL_WIDTH
|
||||
val contentHeight = boardH + 1
|
||||
|
||||
val lines: List<String> = []
|
||||
lines.add("PAUSED")
|
||||
lines.add("")
|
||||
lines.add("Any key: continue game")
|
||||
lines.add("Esc: exit game")
|
||||
lines.add("")
|
||||
lines.add("Move: A/D or arrows")
|
||||
lines.add("Rotate: W or Up")
|
||||
lines.add("Drop: S/Down, Space hard drop")
|
||||
|
||||
var innerWidth = 0
|
||||
for (line in lines) {
|
||||
if (line.size > innerWidth) innerWidth = line.size
|
||||
}
|
||||
innerWidth += 4
|
||||
val maxInner = max(12, contentWidth - 2)
|
||||
if (innerWidth > maxInner) innerWidth = maxInner
|
||||
if (innerWidth % 2 != 0) innerWidth--
|
||||
|
||||
val boxWidth = innerWidth + 2
|
||||
val boxHeight = lines.size + 2
|
||||
|
||||
val left = originCol + max(0, (contentWidth - boxWidth) / 2)
|
||||
val top = originRow + max(0, (contentHeight - boxHeight) / 2)
|
||||
|
||||
val topBorder = UNICODE_TOP_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_TOP_RIGHT
|
||||
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_BOTTOM_RIGHT
|
||||
|
||||
Console.moveTo(top, left)
|
||||
Console.write(topBorder)
|
||||
|
||||
for (i in 0..<lines.size) {
|
||||
Console.moveTo(top + 1 + i, left)
|
||||
Console.write(UNICODE_VERTICAL + fitLine(" " + lines[i], innerWidth) + UNICODE_VERTICAL)
|
||||
}
|
||||
|
||||
Console.moveTo(top + boxHeight - 1, left)
|
||||
Console.write(bottomBorder)
|
||||
}
|
||||
|
||||
fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
|
||||
while (true) {
|
||||
val g = Console.geometry()
|
||||
@@ -351,9 +451,23 @@ fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
|
||||
if (cols >= minCols && rows >= minRows) return g
|
||||
|
||||
clearAndHome()
|
||||
println("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
|
||||
println("Current: %sx%s"(cols, rows))
|
||||
println("Resize the console window to continue...")
|
||||
val lines: List<String> = []
|
||||
lines.add("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
|
||||
lines.add("Current: %sx%s"(cols, rows))
|
||||
lines.add("Resize the console window to continue.")
|
||||
|
||||
val visibleLines = if (rows < lines.size) rows else lines.size
|
||||
if (visibleLines > 0) {
|
||||
val startRow = max(1, ((rows - visibleLines) / 2) + 1)
|
||||
for (i in 0..<visibleLines) {
|
||||
val line = lines[i]
|
||||
val startCol = max(1, ((cols - line.size) / 2) + 1)
|
||||
Console.moveTo(startRow + i, startCol)
|
||||
Console.clearLine()
|
||||
Console.write(line)
|
||||
}
|
||||
Console.flush()
|
||||
}
|
||||
delay(RESIZE_WAIT_MS)
|
||||
}
|
||||
}
|
||||
@@ -379,8 +493,6 @@ fun rot(a: Cell, b: Cell, c: Cell, d: Cell): Rotation {
|
||||
r
|
||||
}
|
||||
|
||||
val PIECES: List<Piece> = []
|
||||
|
||||
val iRots: Rotations = []
|
||||
iRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(3,1)))
|
||||
iRots.add(rot(cell(2,0), cell(2,1), cell(2,2), cell(2,3)))
|
||||
@@ -434,8 +546,8 @@ if (!Console.isSupported()) {
|
||||
val cols = g0?.columns ?: MIN_COLS
|
||||
val rows = g0?.rows ?: MIN_ROWS
|
||||
|
||||
val boardW = clampInt((cols - PANEL_WIDTH) / 2, BOARD_MIN_W, BOARD_MAX_W)
|
||||
val boardH = clampInt(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H, BOARD_MAX_H)
|
||||
val boardW = clamp((cols - PANEL_WIDTH) / 2, BOARD_MIN_W..BOARD_MAX_W)
|
||||
val boardH = clamp(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H..BOARD_MAX_H)
|
||||
|
||||
val board: Board = createBoard(boardW, boardH)
|
||||
|
||||
@@ -452,8 +564,8 @@ if (!Console.isSupported()) {
|
||||
)
|
||||
var prevFrameLines: List<String> = []
|
||||
|
||||
val gameMutex = Mutex()
|
||||
var hasResizeEvent = false
|
||||
var forceRedraw = false
|
||||
val inputBuffer: InputBuffer = InputBuffer()
|
||||
|
||||
val rawModeEnabled = Console.setRawMode(true)
|
||||
if (!rawModeEnabled) {
|
||||
@@ -461,39 +573,66 @@ if (!Console.isSupported()) {
|
||||
println("Use jlyng in an interactive terminal with raw input support.")
|
||||
void
|
||||
} else {
|
||||
val useColor = Console.ansiLevel() != "NONE"
|
||||
val useColor = Console.ansiLevel() != ConsoleAnsiLevel.NONE
|
||||
Console.enterAltScreen()
|
||||
Console.setCursorVisible(false)
|
||||
clearAndHome()
|
||||
|
||||
fun resetActivePiece(s: GameState): Void {
|
||||
s.pieceId = nextPieceId()
|
||||
s.rot = 0
|
||||
s.px = (boardW / 2) - 2
|
||||
s.py = -1
|
||||
}
|
||||
|
||||
fun applyKeyInput(s: GameState, key: String): Void {
|
||||
if (key == "__CTRL_C__" || key == "q" || key == "Q" || key == "Escape") {
|
||||
s.running = false
|
||||
}
|
||||
else if (key == "ArrowLeft" || key == "a" || key == "A") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py)) s.px = s.px - 1
|
||||
}
|
||||
else if (key == "ArrowRight" || key == "d" || key == "D") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py)) s.px = s.px + 1
|
||||
}
|
||||
else if (key == "ArrowUp" || key == "w" || key == "W") {
|
||||
val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)
|
||||
if (rr.ok) {
|
||||
s.rot = rr.rot
|
||||
s.px = rr.px
|
||||
try {
|
||||
if (key == "__CTRL_C__") {
|
||||
s.running = false
|
||||
}
|
||||
}
|
||||
else if (key == "ArrowDown" || key == "s" || key == "S") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) {
|
||||
s.py = s.py + 1
|
||||
s.score = s.score + 1
|
||||
else if (s.paused) {
|
||||
if (key == "Escape") {
|
||||
s.running = false
|
||||
} else {
|
||||
s.paused = false
|
||||
forceRedraw = true
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (key == " ") {
|
||||
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) {
|
||||
s.py = s.py + 1
|
||||
s.score = s.score + 2
|
||||
else if (key == "p" || key == "P" || key == "Escape") {
|
||||
s.paused = true
|
||||
forceRedraw = true
|
||||
}
|
||||
else if (key == "q" || key == "Q") {
|
||||
s.running = false
|
||||
}
|
||||
else if (key == "ArrowLeft" || key == "a" || key == "A") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py) == true) s.px--
|
||||
}
|
||||
else if (key == "ArrowRight" || key == "d" || key == "D") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py) == true) s.px++
|
||||
}
|
||||
else if (key == "ArrowUp" || key == "w" || key == "W") {
|
||||
val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)
|
||||
if (rr.ok) {
|
||||
s.rot = rr.rot
|
||||
s.px = rr.px
|
||||
}
|
||||
}
|
||||
else if (key == "ArrowDown" || key == "s" || key == "S") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
s.score++
|
||||
}
|
||||
}
|
||||
else if (key == " ") {
|
||||
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
s.score += 2
|
||||
}
|
||||
}
|
||||
} catch (inputErr: Object) {
|
||||
logError("applyKeyInput recovered after error", inputErr)
|
||||
resetActivePiece(s)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -503,26 +642,41 @@ if (!Console.isSupported()) {
|
||||
try {
|
||||
for (ev in Console.events()) {
|
||||
if (!inputRunning) break
|
||||
if (ev is ConsoleKeyEvent) {
|
||||
val ke = ev as ConsoleKeyEvent
|
||||
if (ke.type == "keydown") {
|
||||
val key = ke.key
|
||||
val ctrl = ke.ctrl
|
||||
gameMutex.withLock {
|
||||
|
||||
// Isolate per-event failures so one bad event does not unwind the stream.
|
||||
try {
|
||||
if (ev is ConsoleKeyEvent) {
|
||||
val ke = ev as ConsoleKeyEvent
|
||||
if (ke.type == ConsoleEventType.KEY_DOWN) {
|
||||
var key = ""
|
||||
var ctrl = false
|
||||
try {
|
||||
key = ke.key
|
||||
} catch (keyErr: Object) {
|
||||
logError("Input key read error", keyErr)
|
||||
}
|
||||
try {
|
||||
ctrl = ke.ctrl == true
|
||||
} catch (_: Object) {
|
||||
ctrl = false
|
||||
}
|
||||
if (key == "") {
|
||||
logError("Dropped key event with empty/null key", null)
|
||||
continue
|
||||
}
|
||||
val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key
|
||||
applyKeyInput(state, mapped)
|
||||
inputBuffer.push(mapped)
|
||||
}
|
||||
}
|
||||
} else if (ev is ConsoleResizeEvent) {
|
||||
gameMutex.withLock {
|
||||
hasResizeEvent = true
|
||||
prevFrameLines = []
|
||||
}
|
||||
} catch (eventErr: Object) {
|
||||
// Keep the input stream alive; report for diagnostics.
|
||||
logError("Input event error", eventErr)
|
||||
}
|
||||
}
|
||||
} catch (err: Exception) {
|
||||
// Keep game alive: transient console-event failures should not force quit.
|
||||
} catch (err: Object) {
|
||||
// Recover stream-level failures by recreating event stream in next loop turn.
|
||||
if (!inputRunning) break
|
||||
logError("Input stream recovered after error", err)
|
||||
Console.setRawMode(true)
|
||||
delay(50)
|
||||
}
|
||||
@@ -540,16 +694,10 @@ if (!Console.isSupported()) {
|
||||
return null
|
||||
}
|
||||
|
||||
var resized = false
|
||||
gameMutex.withLock {
|
||||
resized = hasResizeEvent
|
||||
hasResizeEvent = false
|
||||
}
|
||||
|
||||
val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH
|
||||
val contentRows = boardH + 1
|
||||
val requiredCols = maxInt(MIN_COLS, contentCols)
|
||||
val requiredRows = maxInt(MIN_ROWS, contentRows)
|
||||
val requiredCols = max(MIN_COLS, contentCols)
|
||||
val requiredRows = max(MIN_ROWS, contentRows)
|
||||
if (c < requiredCols || r < requiredRows) {
|
||||
waitForMinimumSize(requiredCols, requiredRows)
|
||||
clearAndHome()
|
||||
@@ -557,21 +705,21 @@ if (!Console.isSupported()) {
|
||||
return null
|
||||
}
|
||||
|
||||
val originCol = maxInt(1, ((c - contentCols) / 2) + 1)
|
||||
val originRow = maxInt(1, ((r - contentRows) / 2) + 1)
|
||||
LoopFrame(resized, originRow, originCol)
|
||||
val originCol = max(1, ((c - contentCols) / 2) + 1)
|
||||
val originRow = max(1, ((r - contentRows) / 2) + 1)
|
||||
LoopFrame(false, originRow, originCol)
|
||||
}
|
||||
|
||||
fun advanceGravity(s: GameState, frame: Int): Int {
|
||||
s.level = 1 + (s.totalLines / LEVEL_LINES_STEP)
|
||||
val dropEvery = maxInt(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level)
|
||||
val dropEvery = max(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level)
|
||||
|
||||
var nextFrame = frame + 1
|
||||
if (nextFrame < dropEvery) return nextFrame
|
||||
nextFrame = 0
|
||||
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) {
|
||||
s.py = s.py + 1
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
return nextFrame
|
||||
}
|
||||
|
||||
@@ -579,8 +727,8 @@ if (!Console.isSupported()) {
|
||||
|
||||
val cleared = clearCompletedLines(board, boardW, boardH)
|
||||
if (cleared > 0) {
|
||||
s.totalLines = s.totalLines + cleared
|
||||
s.score = s.score + scoreForLines(cleared, s.level)
|
||||
s.totalLines += cleared
|
||||
s.score += scoreForLines(cleared, s.level)
|
||||
}
|
||||
|
||||
s.pieceId = s.nextId
|
||||
@@ -605,37 +753,52 @@ if (!Console.isSupported()) {
|
||||
var shouldStop = false
|
||||
var prevOriginRow = -1
|
||||
var prevOriginCol = -1
|
||||
var prevPaused = false
|
||||
while (!shouldStop) {
|
||||
val frameData = pollLoopFrame()
|
||||
if (frameData == null) {
|
||||
frame = 0
|
||||
prevPaused = false
|
||||
continue
|
||||
}
|
||||
|
||||
gameMutex.withLock {
|
||||
if (!state.running || state.gameOver) {
|
||||
shouldStop = true
|
||||
} else {
|
||||
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
|
||||
if (frameData.resized || movedOrigin) {
|
||||
clearAndHome()
|
||||
prevFrameLines = []
|
||||
}
|
||||
prevOriginRow = frameData.originRow
|
||||
prevOriginCol = frameData.originCol
|
||||
frame = advanceGravity(state, frame)
|
||||
prevFrameLines = render(
|
||||
state,
|
||||
board,
|
||||
boardW,
|
||||
boardH,
|
||||
prevFrameLines,
|
||||
frameData.originRow,
|
||||
frameData.originCol,
|
||||
useColor
|
||||
)
|
||||
val toApply = inputBuffer.drain()
|
||||
if (toApply.size > 0) {
|
||||
for (k in toApply) {
|
||||
applyKeyInput(state, k)
|
||||
if (!state.running || state.gameOver) break
|
||||
}
|
||||
}
|
||||
if (!state.running || state.gameOver) {
|
||||
shouldStop = true
|
||||
} else {
|
||||
val localForceRedraw = forceRedraw
|
||||
forceRedraw = false
|
||||
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
|
||||
if (frameData.resized || movedOrigin || localForceRedraw) {
|
||||
clearAndHome()
|
||||
prevFrameLines = []
|
||||
}
|
||||
prevOriginRow = frameData.originRow
|
||||
prevOriginCol = frameData.originCol
|
||||
if (!state.paused) {
|
||||
frame = advanceGravity(state, frame)
|
||||
}
|
||||
prevFrameLines = render(
|
||||
state,
|
||||
board,
|
||||
boardW,
|
||||
boardH,
|
||||
prevFrameLines,
|
||||
frameData.originRow,
|
||||
frameData.originCol,
|
||||
useColor
|
||||
)
|
||||
if (state.paused && (!prevPaused || frameData.resized || movedOrigin)) {
|
||||
renderPauseOverlay(frameData.originRow, frameData.originCol, boardW, boardH)
|
||||
}
|
||||
prevPaused = state.paused
|
||||
}
|
||||
Console.flush()
|
||||
delay(FRAME_DELAY_MS)
|
||||
}
|
||||
|
||||
+2
-5
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
|
||||
android.useAndroidX=true
|
||||
android.nonTransitiveRClass=true
|
||||
|
||||
# other
|
||||
kotlin.native.cacheKind.linuxX64=none
|
||||
|
||||
# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
|
||||
# On this environment, the system JDK 21 installation lacks `jlink`, causing
|
||||
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`.
|
||||
@@ -37,6 +34,6 @@ kotlin.native.cacheKind.linuxX64=none
|
||||
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
|
||||
android.experimental.lint.migrateToK2=false
|
||||
android.lint.useK2Uast=false
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=false
|
||||
|
||||
org.gradle.parallel=true
|
||||
org.gradle.parallel=true
|
||||
@@ -2,15 +2,19 @@
|
||||
agp = "8.5.2"
|
||||
clikt = "5.0.3"
|
||||
mordant = "3.0.2"
|
||||
kotlin = "2.3.0"
|
||||
kotlin = "2.3.20"
|
||||
android-minSdk = "24"
|
||||
android-compileSdk = "34"
|
||||
kotlinx-coroutines = "1.10.2"
|
||||
kotlinx-datetime = "0.6.1"
|
||||
mp_bintools = "0.3.2"
|
||||
ionspin-bignum = "0.3.10"
|
||||
multik = "0.3.0"
|
||||
firebaseCrashlyticsBuildtools = "3.0.3"
|
||||
okioVersion = "3.10.2"
|
||||
compiler = "3.2.0-alpha11"
|
||||
ktor = "3.3.1"
|
||||
slf4j = "2.0.17"
|
||||
|
||||
[libraries]
|
||||
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
|
||||
@@ -22,11 +26,22 @@ kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-t
|
||||
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
|
||||
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
|
||||
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
|
||||
multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
|
||||
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
|
||||
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
|
||||
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
|
||||
okio-nodefilesystem = { module = "com.squareup.okio:okio-nodefilesystem", version.ref = "okioVersion" }
|
||||
compiler = { group = "androidx.databinding", name = "compiler", version.ref = "compiler" }
|
||||
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
|
||||
ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
|
||||
ktor-client-curl = { module = "io.ktor:ktor-client-curl", version.ref = "ktor" }
|
||||
ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
|
||||
ktor-client-js = { module = "io.ktor:ktor-client-js", version.ref = "ktor" }
|
||||
ktor-client-winhttp = { module = "io.ktor:ktor-client-winhttp", version.ref = "ktor" }
|
||||
ktor-client-websockets = { module = "io.ktor:ktor-client-websockets", version.ref = "ktor" }
|
||||
ktor-network = { module = "io.ktor:ktor-network", version.ref = "ktor" }
|
||||
slf4j-nop = { module = "org.slf4j:slf4j-nop", version.ref = "slf4j" }
|
||||
|
||||
[plugins]
|
||||
androidLibrary = { id = "com.android.library", version.ref = "agp" }
|
||||
|
||||
@@ -23,6 +23,8 @@ import com.intellij.execution.ui.ConsoleViewContentType
|
||||
import com.intellij.openapi.actionSystem.AnAction
|
||||
import com.intellij.openapi.actionSystem.AnActionEvent
|
||||
import com.intellij.openapi.actionSystem.CommonDataKeys
|
||||
import com.intellij.openapi.application.ApplicationManager
|
||||
import com.intellij.openapi.fileEditor.FileDocumentManager
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.openapi.wm.ToolWindow
|
||||
import com.intellij.openapi.wm.ToolWindowAnchor
|
||||
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.launch
|
||||
import net.sergeych.lyng.idea.LyngIcons
|
||||
import java.io.File
|
||||
|
||||
class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
|
||||
private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
|
||||
|
||||
private fun getPsiFile(e: AnActionEvent): PsiFile? {
|
||||
val project = e.project ?: return null
|
||||
@@ -48,36 +51,99 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
}
|
||||
}
|
||||
|
||||
private fun getRunnableFile(e: AnActionEvent): PsiFile? {
|
||||
val psiFile = getPsiFile(e) ?: return null
|
||||
val virtualFile = psiFile.virtualFile ?: return null
|
||||
if (!virtualFile.isInLocalFileSystem) return null
|
||||
if (!psiFile.name.endsWith(".lyng")) return null
|
||||
return psiFile
|
||||
}
|
||||
|
||||
override fun update(e: AnActionEvent) {
|
||||
val psiFile = getPsiFile(e)
|
||||
val isLyng = psiFile?.name?.endsWith(".lyng") == true
|
||||
e.presentation.isEnabledAndVisible = isLyng
|
||||
if (isLyng) {
|
||||
e.presentation.isEnabled = false
|
||||
e.presentation.text = "Run '${psiFile.name}' (disabled)"
|
||||
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
|
||||
val psiFile = getRunnableFile(e)
|
||||
val isRunnable = psiFile != null
|
||||
e.presentation.isEnabledAndVisible = isRunnable
|
||||
if (isRunnable) {
|
||||
e.presentation.text = "Run '${psiFile.name}'"
|
||||
e.presentation.description = "Run the current Lyng script using the Lyng CLI"
|
||||
} else {
|
||||
e.presentation.text = "Run Lyng Script"
|
||||
e.presentation.description = "Run the current Lyng script"
|
||||
}
|
||||
}
|
||||
|
||||
override fun actionPerformed(e: AnActionEvent) {
|
||||
val project = e.project ?: return
|
||||
val psiFile = getPsiFile(e) ?: return
|
||||
val fileName = psiFile.name
|
||||
val psiFile = getRunnableFile(e) ?: return
|
||||
val virtualFile = psiFile.virtualFile ?: return
|
||||
FileDocumentManager.getInstance().getDocument(virtualFile)?.let { document ->
|
||||
FileDocumentManager.getInstance().saveDocument(document)
|
||||
}
|
||||
val filePath = virtualFile.path
|
||||
val workingDir = virtualFile.parent?.path ?: project.basePath ?: File(filePath).parent
|
||||
|
||||
val (console, toolWindow) = getConsoleAndToolWindow(project)
|
||||
console.clear()
|
||||
|
||||
toolWindow.show {
|
||||
scope.launch {
|
||||
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
val command = startLyngProcess(filePath, workingDir)
|
||||
if (command == null) {
|
||||
printToConsole(console, "Unable to start Lyng CLI.\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
printToConsole(console, "Tried commands: lyng, jlyng.\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
printToConsole(console, "Install `lyng` or `jlyng` and make sure it is available on PATH.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
return@launch
|
||||
}
|
||||
|
||||
printToConsole(
|
||||
console,
|
||||
"Running ${command.commandLine} in ${command.workingDir}\n",
|
||||
ConsoleViewContentType.SYSTEM_OUTPUT
|
||||
)
|
||||
streamProcess(command.process, console)
|
||||
val exitCode = command.process.waitFor()
|
||||
val outputType = if (exitCode == 0) ConsoleViewContentType.SYSTEM_OUTPUT else ConsoleViewContentType.ERROR_OUTPUT
|
||||
printToConsole(console, "\nProcess finished with exit code $exitCode\n", outputType)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun streamProcess(process: Process, console: ConsoleView) {
|
||||
val stdout = scope.launch {
|
||||
process.inputStream.bufferedReader().useLines { lines ->
|
||||
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.NORMAL_OUTPUT) }
|
||||
}
|
||||
}
|
||||
val stderr = scope.launch {
|
||||
process.errorStream.bufferedReader().useLines { lines ->
|
||||
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.ERROR_OUTPUT) }
|
||||
}
|
||||
}
|
||||
stdout.join()
|
||||
stderr.join()
|
||||
}
|
||||
|
||||
private fun printToConsole(console: ConsoleView, text: String, type: ConsoleViewContentType) {
|
||||
ApplicationManager.getApplication().invokeLater {
|
||||
console.print(text, type)
|
||||
}
|
||||
}
|
||||
|
||||
private fun startLyngProcess(filePath: String, workingDir: String?): StartedProcess? {
|
||||
val candidates = listOf("lyng", "jlyng")
|
||||
for (candidate in candidates) {
|
||||
try {
|
||||
val process = ProcessBuilder(candidate, filePath)
|
||||
.directory(workingDir?.let(::File))
|
||||
.start()
|
||||
return StartedProcess(process, "$candidate $filePath", workingDir ?: File(filePath).parent.orEmpty())
|
||||
} catch (_: java.io.IOException) {
|
||||
// Try the next candidate when the command is not available.
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
|
||||
val toolWindowManager = ToolWindowManager.getInstance(project)
|
||||
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
|
||||
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
contentManager.setSelectedContent(content)
|
||||
return console to actualToolWindow
|
||||
}
|
||||
|
||||
private data class StartedProcess(
|
||||
val process: Process,
|
||||
val commandLine: String,
|
||||
val workingDir: String
|
||||
)
|
||||
}
|
||||
+15
-10
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -34,8 +34,10 @@ kotlin {
|
||||
// Suppress Beta warning for expect/actual classes across all targets in this module
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -75,19 +77,22 @@ kotlin {
|
||||
implementation(libs.okio.fakefilesystem)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val jvmMain by getting {
|
||||
dependencies {
|
||||
implementation(libs.slf4j.nop)
|
||||
}
|
||||
}
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
implementation(kotlin("test-junit"))
|
||||
}
|
||||
}
|
||||
// val nativeMain by getting {
|
||||
// dependencies {
|
||||
// implementation(kotlin("stdlib-common"))
|
||||
// }
|
||||
// }
|
||||
val linuxX64Main by getting {
|
||||
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -27,16 +27,22 @@ import com.github.ajalt.clikt.parameters.arguments.optional
|
||||
import com.github.ajalt.clikt.parameters.options.flag
|
||||
import com.github.ajalt.clikt.parameters.options.option
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.EvalSession
|
||||
import net.sergeych.lyng.LyngVersion
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.ScriptError
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.io.console.createConsoleModule
|
||||
import net.sergeych.lyng.io.fs.createFs
|
||||
import net.sergeych.lyng.io.http.createHttpModule
|
||||
import net.sergeych.lyng.io.net.createNetModule
|
||||
import net.sergeych.lyng.io.ws.createWsModule
|
||||
import net.sergeych.lyng.obj.*
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
||||
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
|
||||
import net.sergeych.mp_tools.globalDefer
|
||||
import okio.FileSystem
|
||||
import okio.Path.Companion.toPath
|
||||
@@ -74,6 +80,11 @@ val baseScopeDefer = globalDefer {
|
||||
// Install console access by default for interactive CLI scripts.
|
||||
// Scripts still need to `import lyng.io.console` to use it.
|
||||
createConsoleModule(PermitAllConsoleAccessPolicy, this)
|
||||
// Install network-oriented lyngio modules for CLI scripts.
|
||||
// Scripts still need to import the modules they use explicitly.
|
||||
createHttpModule(PermitAllHttpAccessPolicy, this)
|
||||
createWsModule(PermitAllWsAccessPolicy, this)
|
||||
createNetModule(PermitAllNetAccessPolicy, this)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -158,6 +169,7 @@ private class Fmt : CliktCommand(name = "fmt") {
|
||||
|
||||
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
|
||||
|
||||
override val invokeWithoutSubcommand = true
|
||||
override val printHelpOnEmptyArgs = true
|
||||
|
||||
val version by option("-v", "--version", help = "Print version and exit").flag()
|
||||
@@ -204,12 +216,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
|
||||
launcher {
|
||||
// there is no script name, it is a first argument instead:
|
||||
processErrors {
|
||||
val script = Compiler.compileWithResolution(
|
||||
Source("<eval>", execute!!),
|
||||
baseScope.currentImportProvider,
|
||||
seedScope = baseScope
|
||||
)
|
||||
script.execute(baseScope)
|
||||
executeSource(Source("<eval>", execute!!))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -235,6 +242,15 @@ fun executeFileWithArgs(fileName: String, args: List<String>) {
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun executeSource(source: Source) {
|
||||
val session = EvalSession(baseScopeDefer.await())
|
||||
try {
|
||||
session.eval(source)
|
||||
} finally {
|
||||
session.cancelAndJoin()
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun executeFile(fileName: String) {
|
||||
var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
|
||||
fileSource.buffer().use { bs ->
|
||||
@@ -247,13 +263,7 @@ suspend fun executeFile(fileName: String) {
|
||||
text = text.substring(pos + 1)
|
||||
}
|
||||
processErrors {
|
||||
val scope = baseScopeDefer.await()
|
||||
val script = Compiler.compileWithResolution(
|
||||
Source(fileName, text),
|
||||
scope.currentImportProvider,
|
||||
seedScope = scope
|
||||
)
|
||||
script.execute(scope)
|
||||
executeSource(Source(fileName, text))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -131,4 +131,18 @@ class CliFmtJvmTest {
|
||||
Files.deleteIfExists(tmp)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun inlineExecuteWithDashXStillWorksAndPassesArgv() {
|
||||
val r = runCli(
|
||||
"-x",
|
||||
"""println("INLINE"); println(ARGV[0]); println(ARGV[1])""",
|
||||
"one",
|
||||
"two"
|
||||
)
|
||||
assertTrue("Expected inline execution output", r.out.contains("INLINE"))
|
||||
assertTrue("Expected ARGV to include first trailing arg", r.out.contains("one"))
|
||||
assertTrue("Expected ARGV to include second trailing arg", r.out.contains("two"))
|
||||
assertTrue("Did not expect CLI exit()", r.exitCode == null)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng_cli
|
||||
|
||||
import com.sun.net.httpserver.HttpExchange
|
||||
import com.sun.net.httpserver.HttpServer
|
||||
import net.sergeych.jvmExitImpl
|
||||
import net.sergeych.runMain
|
||||
import org.junit.After
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import java.io.ByteArrayOutputStream
|
||||
import java.io.PrintStream
|
||||
import java.net.InetSocketAddress
|
||||
|
||||
class CliNetworkJvmTest {
|
||||
private val originalOut: PrintStream = System.out
|
||||
private val originalErr: PrintStream = System.err
|
||||
|
||||
private class TestExit(val code: Int) : RuntimeException()
|
||||
|
||||
@Before
|
||||
fun setUp() {
|
||||
jvmExitImpl = { code -> throw TestExit(code) }
|
||||
}
|
||||
|
||||
@After
|
||||
fun tearDown() {
|
||||
System.setOut(originalOut)
|
||||
System.setErr(originalErr)
|
||||
jvmExitImpl = { code -> kotlin.system.exitProcess(code) }
|
||||
}
|
||||
|
||||
private data class CliResult(val out: String, val err: String, val exitCode: Int?)
|
||||
|
||||
private fun runCli(vararg args: String): CliResult {
|
||||
val outBuf = ByteArrayOutputStream()
|
||||
val errBuf = ByteArrayOutputStream()
|
||||
System.setOut(PrintStream(outBuf, true, Charsets.UTF_8))
|
||||
System.setErr(PrintStream(errBuf, true, Charsets.UTF_8))
|
||||
|
||||
var exitCode: Int? = null
|
||||
try {
|
||||
runMain(arrayOf(*args))
|
||||
} catch (e: TestExit) {
|
||||
exitCode = e.code
|
||||
} finally {
|
||||
System.out.flush()
|
||||
System.err.flush()
|
||||
}
|
||||
return CliResult(outBuf.toString("UTF-8"), errBuf.toString("UTF-8"), exitCode)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun cliHasAllNetworkingModulesInstalled() {
|
||||
val server = newServer()
|
||||
try {
|
||||
val script = """
|
||||
import lyng.io.http
|
||||
import lyng.io.ws
|
||||
import lyng.io.net
|
||||
|
||||
assert(Http.isSupported())
|
||||
println("ws=" + Ws.isSupported())
|
||||
println("net=" + Net.isSupported())
|
||||
|
||||
val home = Http.get("http://127.0.0.1:${server.address.port}/").text()
|
||||
val jsRef = "src=\"([^\"]*lyng-version\\.js)\"".re.find(home)
|
||||
require(jsRef != null, "lyng-version.js reference not found")
|
||||
|
||||
val versionJsPath = (jsRef as RegexMatch)[1]
|
||||
val versionJs = Http.get("http://127.0.0.1:${server.address.port}/" + versionJsPath).text()
|
||||
val versionMatch = "LYNG_VERSION\\s*=\\s*\"([^\"]+)\"".re.find(versionJs)
|
||||
require(versionMatch != null, "LYNG_VERSION assignment not found")
|
||||
|
||||
println("version=" + ((versionMatch as RegexMatch)[1]))
|
||||
""".trimIndent()
|
||||
|
||||
val result = runCli("-x", script)
|
||||
assertNull(result.exitCode)
|
||||
assertTrue(result.err, result.err.isBlank())
|
||||
assertTrue(result.out, result.out.contains("ws="))
|
||||
assertTrue(result.out, result.out.contains("net="))
|
||||
assertTrue(result.out, result.out.contains("version=9.9.9-test"))
|
||||
} finally {
|
||||
server.stop(0)
|
||||
}
|
||||
}
|
||||
|
||||
private fun newServer(): HttpServer {
|
||||
val server = HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
|
||||
server.createContext("/") { exchange ->
|
||||
when (exchange.requestURI.path) {
|
||||
"/" -> writeResponse(
|
||||
exchange,
|
||||
200,
|
||||
"""
|
||||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<script src="lyng-version.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<span id="lyng-version-ribbon"></span>
|
||||
</body>
|
||||
</html>
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
"/lyng-version.js" -> writeResponse(exchange, 200, """window.LYNG_VERSION = "9.9.9-test";""")
|
||||
else -> writeResponse(exchange, 404, "missing")
|
||||
}
|
||||
}
|
||||
server.start()
|
||||
return server
|
||||
}
|
||||
|
||||
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
|
||||
val bytes = body.toByteArray()
|
||||
exchange.sendResponseHeaders(status, bytes.size.toLong())
|
||||
exchange.responseBody.use { out ->
|
||||
out.write(bytes)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -31,11 +31,12 @@ class FsIntegrationJvmTest {
|
||||
val dir = createTempDirectory("lyng_cli_fs_test_")
|
||||
try {
|
||||
val file = dir.resolve("hello.txt")
|
||||
val filePath = file.toString().replace("\\", "\\\\")
|
||||
// Drive the operation via Lyng code to validate bindings end-to-end
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.io.fs
|
||||
val p = Path("${'$'}{file}")
|
||||
val p = Path("${filePath}")
|
||||
p.writeUtf8("hello from cli test")
|
||||
assertEquals(true, p.exists())
|
||||
assertEquals("hello from cli test", p.readUtf8())
|
||||
|
||||
+125
-3
@@ -44,7 +44,6 @@ kotlin {
|
||||
iosX64()
|
||||
iosArm64()
|
||||
iosSimulatorArm64()
|
||||
macosX64()
|
||||
macosArm64()
|
||||
mingwX64()
|
||||
linuxX64()
|
||||
@@ -62,8 +61,10 @@ kotlin {
|
||||
// Keep expect/actual warning suppressed consistently with other modules
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -79,13 +80,58 @@ kotlin {
|
||||
api(libs.okio)
|
||||
api(libs.kotlinx.coroutines.core)
|
||||
api(libs.mordant.core)
|
||||
api(libs.ktor.client.core)
|
||||
implementation(libs.ktor.client.websockets)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
dependencies {
|
||||
implementation(libs.ktor.network)
|
||||
}
|
||||
}
|
||||
val darwinMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
dependencies {
|
||||
implementation(libs.ktor.client.darwin)
|
||||
}
|
||||
}
|
||||
val iosMain by creating {
|
||||
dependsOn(darwinMain)
|
||||
}
|
||||
val linuxMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
dependencies {
|
||||
implementation(libs.ktor.client.curl)
|
||||
}
|
||||
}
|
||||
val macosMain by creating {
|
||||
dependsOn(darwinMain)
|
||||
}
|
||||
val mingwMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
dependencies {
|
||||
implementation(libs.ktor.client.winhttp)
|
||||
}
|
||||
}
|
||||
val commonTest by getting {
|
||||
dependencies {
|
||||
implementation(libs.kotlin.test)
|
||||
implementation(libs.kotlinx.coroutines.test)
|
||||
}
|
||||
}
|
||||
val linuxTest by creating {
|
||||
dependsOn(commonTest)
|
||||
}
|
||||
val iosX64Main by getting { dependsOn(iosMain) }
|
||||
val iosArm64Main by getting { dependsOn(iosMain) }
|
||||
val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
|
||||
val macosArm64Main by getting { dependsOn(macosMain) }
|
||||
val mingwX64Main by getting { dependsOn(mingwMain) }
|
||||
val linuxX64Main by getting { dependsOn(linuxMain) }
|
||||
val linuxArm64Main by getting { dependsOn(linuxMain) }
|
||||
val linuxX64Test by getting { dependsOn(linuxTest) }
|
||||
val linuxArm64Test by getting { dependsOn(linuxTest) }
|
||||
|
||||
// JS: use runtime detection in jsMain to select Node vs Browser implementation
|
||||
val jsMain by getting {
|
||||
@@ -93,6 +139,13 @@ kotlin {
|
||||
api(libs.okio)
|
||||
implementation(libs.okio.fakefilesystem)
|
||||
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
|
||||
implementation(libs.ktor.client.js)
|
||||
}
|
||||
}
|
||||
val androidMain by getting {
|
||||
dependencies {
|
||||
implementation(libs.ktor.client.cio)
|
||||
implementation(libs.ktor.network)
|
||||
}
|
||||
}
|
||||
val jvmMain by getting {
|
||||
@@ -100,6 +153,8 @@ kotlin {
|
||||
implementation(libs.mordant.jvm.jna)
|
||||
implementation("org.jline:jline-reader:3.29.0")
|
||||
implementation("org.jline:jline-terminal:3.29.0")
|
||||
implementation(libs.ktor.client.cio)
|
||||
implementation(libs.ktor.network)
|
||||
}
|
||||
}
|
||||
// // For Wasm we use in-memory VFS for now
|
||||
@@ -112,6 +167,73 @@ kotlin {
|
||||
}
|
||||
}
|
||||
|
||||
abstract class GenerateLyngioDecls : DefaultTask() {
|
||||
@get:InputDirectory
|
||||
@get:PathSensitive(PathSensitivity.RELATIVE)
|
||||
abstract val sourceDir: DirectoryProperty
|
||||
|
||||
@get:OutputDirectory
|
||||
abstract val outputDir: DirectoryProperty
|
||||
|
||||
@TaskAction
|
||||
fun generate() {
|
||||
val targetPkg = "net.sergeych.lyngio.stdlib_included"
|
||||
val pkgPath = targetPkg.replace('.', '/')
|
||||
val targetDir = outputDir.get().asFile.resolve(pkgPath)
|
||||
if (targetDir.exists()) targetDir.deleteRecursively()
|
||||
targetDir.mkdirs()
|
||||
|
||||
fun escapeForQuoted(s: String): String = buildString {
|
||||
for (ch in s) when (ch) {
|
||||
'\\' -> append("\\\\")
|
||||
'"' -> append("\\\"")
|
||||
'\n' -> append("\\n")
|
||||
'\r' -> {}
|
||||
'\t' -> append("\\t")
|
||||
else -> append(ch)
|
||||
}
|
||||
}
|
||||
|
||||
val out = buildString {
|
||||
append("package ").append(targetPkg).append("\n\n")
|
||||
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
sourceDir.get().asFile
|
||||
.listFiles { file -> file.isFile && file.extension == "lyng" }
|
||||
?.sortedBy { it.name }
|
||||
?.forEach { file ->
|
||||
val propertyName = buildString {
|
||||
append(file.nameWithoutExtension)
|
||||
append("Lyng")
|
||||
}
|
||||
append("internal val ").append(propertyName).append(" = \"")
|
||||
append(escapeForQuoted(file.readText()))
|
||||
append("\"\n")
|
||||
}
|
||||
}
|
||||
targetDir.resolve("lyngio_types_lyng.generated.kt").writeText(out)
|
||||
}
|
||||
}
|
||||
|
||||
val lyngioDeclsDir = layout.projectDirectory.dir("stdlib/lyng/io")
|
||||
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
|
||||
|
||||
val generateLyngioDecls by tasks.registering(GenerateLyngioDecls::class) {
|
||||
sourceDir.set(lyngioDeclsDir)
|
||||
outputDir.set(generatedLyngioDeclsDir)
|
||||
}
|
||||
|
||||
kotlin.sourceSets.named("commonMain") {
|
||||
kotlin.srcDir(generateLyngioDecls)
|
||||
}
|
||||
|
||||
kotlin.targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compileTaskProvider.configure {
|
||||
dependsOn(generateLyngioDecls)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
android {
|
||||
namespace = "net.sergeych.lyngio"
|
||||
compileSdk = libs.versions.android.compileSdk.get().toInt()
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.cio.CIO
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(CIO)
|
||||
@@ -0,0 +1,206 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
import io.ktor.network.selector.ActorSelectorManager
|
||||
import io.ktor.network.selector.SelectorManager
|
||||
import io.ktor.network.sockets.BoundDatagramSocket
|
||||
import io.ktor.network.sockets.InetSocketAddress
|
||||
import io.ktor.network.sockets.ServerSocket
|
||||
import io.ktor.network.sockets.Socket
|
||||
import io.ktor.network.sockets.aSocket
|
||||
import io.ktor.network.sockets.isClosed
|
||||
import io.ktor.network.sockets.openReadChannel
|
||||
import io.ktor.network.sockets.openWriteChannel
|
||||
import io.ktor.network.sockets.toJavaAddress
|
||||
import io.ktor.utils.io.ByteReadChannel
|
||||
import io.ktor.utils.io.ByteWriteChannel
|
||||
import io.ktor.utils.io.readAvailable
|
||||
import io.ktor.utils.io.readUTF8Line
|
||||
import io.ktor.utils.io.writeFully
|
||||
import io.ktor.utils.io.writeStringUtf8
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import kotlinx.io.Buffer
|
||||
import kotlinx.io.readByteArray
|
||||
import java.net.Inet4Address
|
||||
import java.net.Inet6Address
|
||||
import java.net.InetAddress
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = AndroidKtorNetEngine
|
||||
|
||||
private object AndroidKtorNetEngine : LyngNetEngine {
|
||||
private val selectorManager: SelectorManager by lazy { ActorSelectorManager(Dispatchers.IO) }
|
||||
|
||||
override val isSupported: Boolean = true
|
||||
override val isTcpAvailable: Boolean = true
|
||||
override val isTcpServerAvailable: Boolean = true
|
||||
override val isUdpAvailable: Boolean = true
|
||||
|
||||
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> = withContext(Dispatchers.IO) {
|
||||
InetAddress.getAllByName(host).map { address ->
|
||||
address.toLyngSocketAddress(port = port, resolved = true)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun tcpConnect(
|
||||
host: String,
|
||||
port: Int,
|
||||
timeoutMillis: Long?,
|
||||
noDelay: Boolean,
|
||||
): LyngTcpSocket {
|
||||
val connectBlock: suspend () -> Socket = {
|
||||
aSocket(selectorManager).tcp().connect(host, port) {
|
||||
this.noDelay = noDelay
|
||||
}
|
||||
}
|
||||
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
|
||||
return AndroidLyngTcpSocket(socket)
|
||||
}
|
||||
|
||||
override suspend fun tcpListen(
|
||||
host: String?,
|
||||
port: Int,
|
||||
backlog: Int,
|
||||
reuseAddress: Boolean,
|
||||
): LyngTcpServer {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
|
||||
backlogSize = backlog
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return AndroidLyngTcpServer(server)
|
||||
}
|
||||
|
||||
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return AndroidLyngUdpSocket(socket)
|
||||
}
|
||||
}
|
||||
|
||||
private class AndroidLyngTcpSocket(
|
||||
private val socket: Socket,
|
||||
) : LyngTcpSocket {
|
||||
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
|
||||
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
|
||||
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun read(maxBytes: Int): ByteArray? {
|
||||
if (!input.awaitContent(1)) return null
|
||||
val buffer = ByteArray(maxBytes)
|
||||
val count = input.readAvailable(buffer, 0, maxBytes)
|
||||
return when {
|
||||
count <= 0 -> null
|
||||
count == maxBytes -> buffer
|
||||
else -> buffer.copyOf(count)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun readLine(): String? = input.readUTF8Line()
|
||||
|
||||
override suspend fun write(data: ByteArray) {
|
||||
output.writeFully(data, 0, data.size)
|
||||
}
|
||||
|
||||
override suspend fun writeUtf8(text: String) {
|
||||
output.writeStringUtf8(text)
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
output.flush()
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class AndroidLyngTcpServer(
|
||||
private val server: ServerSocket,
|
||||
) : LyngTcpServer {
|
||||
override fun isOpen(): Boolean = !server.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun accept(): LyngTcpSocket = AndroidLyngTcpSocket(server.accept())
|
||||
|
||||
override fun close() {
|
||||
server.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class AndroidLyngUdpSocket(
|
||||
private val socket: BoundDatagramSocket,
|
||||
) : LyngUdpSocket {
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun receive(maxBytes: Int): LyngDatagram? {
|
||||
val datagram = try {
|
||||
socket.receive()
|
||||
} catch (e: Throwable) {
|
||||
if (!isOpen()) return null
|
||||
throw e
|
||||
}
|
||||
val bytes = datagram.packet.readByteArray().let {
|
||||
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
|
||||
}
|
||||
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
|
||||
}
|
||||
|
||||
override suspend fun send(data: ByteArray, host: String, port: Int) {
|
||||
val packet = Buffer()
|
||||
packet.write(data)
|
||||
socket.send(io.ktor.network.sockets.Datagram(packet, InetSocketAddress(host, port)))
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private fun io.ktor.network.sockets.SocketAddress.toLyngSocketAddress(
|
||||
port: Int? = null,
|
||||
resolved: Boolean,
|
||||
): LyngSocketAddress {
|
||||
val javaAddress = this.toJavaAddress()
|
||||
val inetSocket = javaAddress as? java.net.InetSocketAddress
|
||||
if (inetSocket != null) {
|
||||
val inetAddress = inetSocket.address
|
||||
val host = inetAddress?.hostAddress ?: inetSocket.hostString
|
||||
val actualPort = port ?: inetSocket.port
|
||||
val version = when (inetAddress) {
|
||||
is Inet6Address -> LyngIpVersion.IPV6
|
||||
is Inet4Address -> LyngIpVersion.IPV4
|
||||
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
|
||||
}
|
||||
return LyngSocketAddress(host = host, port = actualPort, ipVersion = version, resolved = resolved)
|
||||
}
|
||||
|
||||
val rendered = toString()
|
||||
return LyngSocketAddress(
|
||||
host = rendered,
|
||||
port = port ?: 0,
|
||||
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = resolved,
|
||||
)
|
||||
}
|
||||
|
||||
private fun InetAddress.toLyngSocketAddress(port: Int, resolved: Boolean): LyngSocketAddress =
|
||||
LyngSocketAddress(
|
||||
host = hostAddress ?: hostName ?: "0.0.0.0",
|
||||
port = port,
|
||||
ipVersion = when (this) {
|
||||
is Inet6Address -> LyngIpVersion.IPV6
|
||||
else -> LyngIpVersion.IPV4
|
||||
},
|
||||
resolved = resolved,
|
||||
)
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.cio.CIO
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(CIO)
|
||||
@@ -17,12 +17,15 @@
|
||||
|
||||
package net.sergeych.lyng.io.console
|
||||
|
||||
import kotlinx.coroutines.delay
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjEnumClass
|
||||
import net.sergeych.lyng.obj.ObjEnumEntry
|
||||
import net.sergeych.lyng.obj.ObjIterable
|
||||
import net.sergeych.lyng.obj.ObjIterationFinishedException
|
||||
import net.sergeych.lyng.obj.ObjIterator
|
||||
@@ -35,13 +38,13 @@ import net.sergeych.lyng.obj.toObj
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.raiseIllegalOperation
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyngio.console.ConsoleEvent
|
||||
import net.sergeych.lyngio.console.ConsoleEventSource
|
||||
import net.sergeych.lyngio.console.LyngConsole
|
||||
import net.sergeych.lyngio.console.getSystemConsole
|
||||
import net.sergeych.lyngio.console.*
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.console.security.LyngConsoleSecured
|
||||
import net.sergeych.lyngio.stdlib_included.consoleLyng
|
||||
|
||||
private const val CONSOLE_MODULE_NAME = "lyng.io.console"
|
||||
|
||||
/**
|
||||
* Install Lyng module `lyng.io.console` into the given scope's ImportManager.
|
||||
@@ -53,71 +56,61 @@ fun createConsole(policy: ConsoleAccessPolicy, scope: Scope): Boolean = createCo
|
||||
|
||||
/** Same as [createConsoleModule] but with explicit [ImportManager]. */
|
||||
fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean {
|
||||
val name = "lyng.io.console"
|
||||
if (manager.packageNames.contains(name)) return false
|
||||
if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
|
||||
|
||||
manager.addPackage(name) { module ->
|
||||
buildConsoleModule(module, policy)
|
||||
manager.addPackage(CONSOLE_MODULE_NAME) { module ->
|
||||
buildConsoleModule(module, policy, getSystemConsole())
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager)
|
||||
|
||||
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) {
|
||||
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
|
||||
internal fun createConsoleModule(
|
||||
policy: ConsoleAccessPolicy,
|
||||
manager: ImportManager,
|
||||
console: LyngConsole,
|
||||
): Boolean {
|
||||
if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
|
||||
|
||||
manager.addPackage(CONSOLE_MODULE_NAME) { module ->
|
||||
buildConsoleModule(module, policy, console)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy, baseConsole: LyngConsole) {
|
||||
// Load Lyng declarations for console enums/types first (module-local source of truth).
|
||||
module.eval(Source(CONSOLE_MODULE_NAME, consoleLyng))
|
||||
ConsoleEnums.initialize(module)
|
||||
val console: LyngConsole = LyngConsoleSecured(baseConsole, policy)
|
||||
|
||||
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
|
||||
|
||||
consoleType.apply {
|
||||
addClassFnDoc(
|
||||
name = "isSupported",
|
||||
doc = "Whether console control API is supported on this platform.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("isSupported") {
|
||||
ObjBool(console.isSupported)
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "isTty",
|
||||
doc = "Whether current stdout is attached to an interactive TTY.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("isTty") {
|
||||
consoleGuard {
|
||||
ObjBool(console.isTty())
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "ansiLevel",
|
||||
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("ansiLevel") {
|
||||
consoleGuard {
|
||||
ObjString(console.ansiLevel().name)
|
||||
ConsoleEnums.ansiLevel(console.ansiLevel().name)
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "geometry",
|
||||
doc = "Current terminal geometry or null.",
|
||||
returns = type("ConsoleGeometry", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("geometry") {
|
||||
consoleGuard {
|
||||
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "details",
|
||||
doc = "Get consolidated console details.",
|
||||
returns = type("ConsoleDetails"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("details") {
|
||||
consoleGuard {
|
||||
val tty = console.isTty()
|
||||
val ansi = console.ansiLevel()
|
||||
@@ -125,18 +118,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
|
||||
ObjConsoleDetails(
|
||||
supported = console.isSupported,
|
||||
isTty = tty,
|
||||
ansiLevel = ansi.name,
|
||||
ansiLevel = ConsoleEnums.ansiLevel(ansi.name),
|
||||
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "write",
|
||||
doc = "Write text directly to console output.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("write") {
|
||||
consoleGuard {
|
||||
val text = requiredArg<ObjString>(0).value
|
||||
console.write(text)
|
||||
@@ -144,48 +132,28 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "flush",
|
||||
doc = "Flush console output buffer.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("flush") {
|
||||
consoleGuard {
|
||||
console.flush()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "home",
|
||||
doc = "Move cursor to home position (1,1).",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("home") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[H")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "clear",
|
||||
doc = "Clear the visible screen buffer.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("clear") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[2J")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "moveTo",
|
||||
doc = "Move cursor to 1-based row and column.",
|
||||
params = listOf(
|
||||
ParamDoc("row", type("lyng.Int")),
|
||||
ParamDoc("column", type("lyng.Int")),
|
||||
),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("moveTo") {
|
||||
consoleGuard {
|
||||
val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value
|
||||
val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value
|
||||
@@ -194,45 +162,28 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "clearLine",
|
||||
doc = "Clear the current line.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("clearLine") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[2K")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "enterAltScreen",
|
||||
doc = "Switch to terminal alternate screen buffer.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("enterAltScreen") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[?1049h")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "leaveAltScreen",
|
||||
doc = "Return from alternate screen buffer to normal screen.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("leaveAltScreen") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[?1049l")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "setCursorVisible",
|
||||
doc = "Show or hide the terminal cursor.",
|
||||
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("setCursorVisible") {
|
||||
consoleGuard {
|
||||
val visible = requiredArg<ObjBool>(0).value
|
||||
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
|
||||
@@ -240,24 +191,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "events",
|
||||
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
|
||||
returns = type("ConsoleEventStream"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("events") {
|
||||
consoleGuard {
|
||||
console.events().toConsoleEventStream()
|
||||
ObjConsoleEventStream { console.events() }
|
||||
}
|
||||
}
|
||||
|
||||
addClassFnDoc(
|
||||
name = "setRawMode",
|
||||
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
|
||||
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
addClassFn("setRawMode") {
|
||||
consoleGuard {
|
||||
val enabled = requiredArg<ObjBool>(0).value
|
||||
ObjBool(console.setRawMode(enabled))
|
||||
@@ -265,55 +205,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
|
||||
}
|
||||
}
|
||||
|
||||
module.addConstDoc(
|
||||
name = "Console",
|
||||
value = consoleType,
|
||||
doc = "Console runtime API.",
|
||||
type = type("Console"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleGeometry",
|
||||
value = ObjConsoleGeometry.type,
|
||||
doc = "Terminal geometry.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleDetails",
|
||||
value = ObjConsoleDetails.type,
|
||||
doc = "Consolidated console capability details.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleEvent",
|
||||
value = ObjConsoleEvent.type,
|
||||
doc = "Base class for console events.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleResizeEvent",
|
||||
value = ObjConsoleResizeEvent.type,
|
||||
doc = "Terminal resize event.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleKeyEvent",
|
||||
value = ObjConsoleKeyEvent.typeObj,
|
||||
doc = "Keyboard event.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConstDoc(
|
||||
name = "ConsoleEventStream",
|
||||
value = ObjConsoleEventStream.type,
|
||||
doc = "Endless iterable stream of console events.",
|
||||
type = type("lyng.Class"),
|
||||
moduleName = module.packageName
|
||||
)
|
||||
module.addConst("Console", consoleType)
|
||||
module.addConst("ConsoleGeometry", ObjConsoleGeometry.type)
|
||||
module.addConst("ConsoleDetails", ObjConsoleDetails.type)
|
||||
module.addConst("ConsoleEvent", ObjConsoleEvent.type)
|
||||
module.addConst("ConsoleResizeEvent", ObjConsoleResizeEvent.type)
|
||||
module.addConst("ConsoleKeyEvent", ObjConsoleKeyEvent.typeObj)
|
||||
module.addConst("ConsoleEventStream", ObjConsoleEventStream.type)
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
@@ -326,56 +224,90 @@ private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend (
|
||||
}
|
||||
}
|
||||
|
||||
private fun ConsoleEventSource.toConsoleEventStream(): ObjConsoleEventStream {
|
||||
return ObjConsoleEventStream(this)
|
||||
}
|
||||
|
||||
private class ObjConsoleEventStream(
|
||||
private val source: ConsoleEventSource,
|
||||
private val sourceFactory: () -> ConsoleEventSource,
|
||||
) : Obj() {
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||
get() = type
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply {
|
||||
addFnDoc(
|
||||
name = "iterator",
|
||||
doc = "Create an iterator over incoming console events.",
|
||||
returns = type("lyng.Iterator"),
|
||||
moduleName = "lyng.io.console",
|
||||
) {
|
||||
addFn("iterator") {
|
||||
val stream = thisAs<ObjConsoleEventStream>()
|
||||
ObjConsoleEventIterator(stream.source)
|
||||
ObjConsoleEventIterator(stream.sourceFactory)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleEventIterator(
|
||||
private val source: ConsoleEventSource,
|
||||
private val sourceFactory: () -> ConsoleEventSource,
|
||||
) : Obj() {
|
||||
private var cached: Obj? = null
|
||||
private var closed = false
|
||||
private var source: ConsoleEventSource? = null
|
||||
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||
get() = type
|
||||
|
||||
private fun ensureSource(): ConsoleEventSource {
|
||||
val current = source
|
||||
if (current != null) return current
|
||||
return sourceFactory().also { source = it }
|
||||
}
|
||||
|
||||
private suspend fun recycleSource(reason: String, error: Throwable? = null) {
|
||||
if (error != null) {
|
||||
consoleFlowDebug(reason, error)
|
||||
} else {
|
||||
consoleFlowDebug(reason)
|
||||
}
|
||||
val current = source
|
||||
source = null
|
||||
runCatching { current?.close() }
|
||||
.onFailure { consoleFlowDebug("console-bridge: failed to close recycled source", it) }
|
||||
if (!closed) delay(25)
|
||||
}
|
||||
|
||||
private suspend fun ensureCached(): Boolean {
|
||||
if (closed) return false
|
||||
if (cached != null) return true
|
||||
val event = source.nextEvent()
|
||||
if (event == null) {
|
||||
closeSource()
|
||||
return false
|
||||
while (!closed && cached == null) {
|
||||
val currentSource = try {
|
||||
ensureSource()
|
||||
} catch (e: Throwable) {
|
||||
recycleSource("console-bridge: source creation failed; retrying", e)
|
||||
continue
|
||||
}
|
||||
val event = try {
|
||||
currentSource.nextEvent()
|
||||
} catch (e: Throwable) {
|
||||
// Consumer loops must survive source/read failures: rebuild the source and keep polling.
|
||||
recycleSource("console-bridge: nextEvent failed; recycling source", e)
|
||||
continue
|
||||
}
|
||||
if (event == null) {
|
||||
recycleSource("console-bridge: source ended; recreating")
|
||||
continue
|
||||
}
|
||||
cached = try {
|
||||
event.toObjEvent()
|
||||
} catch (e: Throwable) {
|
||||
// Malformed/native event payload must not terminate consumer iteration.
|
||||
consoleFlowDebug("console-bridge: malformed event dropped: $event", e)
|
||||
null
|
||||
}
|
||||
}
|
||||
cached = event.toObjEvent()
|
||||
return true
|
||||
return cached != null
|
||||
}
|
||||
|
||||
private suspend fun closeSource() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
source.close()
|
||||
val current = source
|
||||
source = null
|
||||
runCatching { current?.close() }
|
||||
.onFailure { consoleFlowDebug("console-bridge: failed to close iterator source", it) }
|
||||
}
|
||||
|
||||
suspend fun hasNext(): Boolean = ensureCached()
|
||||
@@ -391,28 +323,13 @@ private class ObjConsoleEventIterator(
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply {
|
||||
addFnDoc(
|
||||
name = "hasNext",
|
||||
doc = "Whether another console event is available.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
) {
|
||||
addFn("hasNext") {
|
||||
thisAs<ObjConsoleEventIterator>().hasNext().toObj()
|
||||
}
|
||||
addFnDoc(
|
||||
name = "next",
|
||||
doc = "Return the next console event.",
|
||||
returns = type("ConsoleEvent"),
|
||||
moduleName = "lyng.io.console",
|
||||
) {
|
||||
addFn("next") {
|
||||
thisAs<ObjConsoleEventIterator>().next(requireScope())
|
||||
}
|
||||
addFnDoc(
|
||||
name = "cancelIteration",
|
||||
doc = "Stop reading console events and release resources.",
|
||||
returns = type("lyng.Void"),
|
||||
moduleName = "lyng.io.console",
|
||||
) {
|
||||
addFn("cancelIteration") {
|
||||
thisAs<ObjConsoleEventIterator>().closeSource()
|
||||
ObjVoid
|
||||
}
|
||||
@@ -422,27 +339,119 @@ private class ObjConsoleEventIterator(
|
||||
|
||||
private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
|
||||
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
|
||||
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = "keydown", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = "keyup", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_DOWN, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_UP, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
}
|
||||
|
||||
private fun sanitizedKeyOrFallback(key: String): String {
|
||||
if (key.isNotEmpty()) return key
|
||||
consoleFlowDebug("console-bridge: empty key value received; using fallback key name")
|
||||
return "Unknown"
|
||||
}
|
||||
|
||||
private object ConsoleEnums {
|
||||
lateinit var eventTypeClass: ObjEnumClass
|
||||
private set
|
||||
lateinit var keyCodeClass: ObjEnumClass
|
||||
private set
|
||||
lateinit var ansiLevelClass: ObjEnumClass
|
||||
private set
|
||||
|
||||
private lateinit var eventEntries: Map<String, ObjEnumEntry>
|
||||
private lateinit var keyCodeEntries: Map<String, ObjEnumEntry>
|
||||
private lateinit var ansiLevelEntries: Map<String, ObjEnumEntry>
|
||||
|
||||
val UNKNOWN: ObjEnumEntry get() = event("UNKNOWN")
|
||||
val RESIZE: ObjEnumEntry get() = event("RESIZE")
|
||||
val KEY_DOWN: ObjEnumEntry get() = event("KEY_DOWN")
|
||||
val KEY_UP: ObjEnumEntry get() = event("KEY_UP")
|
||||
val CODE_UNKNOWN: ObjEnumEntry get() = code("UNKNOWN")
|
||||
val CHARACTER: ObjEnumEntry get() = code("CHARACTER")
|
||||
|
||||
fun initialize(module: ModuleScope) {
|
||||
eventTypeClass = resolveEnum(module, "ConsoleEventType")
|
||||
keyCodeClass = resolveEnum(module, "ConsoleKeyCode")
|
||||
ansiLevelClass = resolveEnum(module, "ConsoleAnsiLevel")
|
||||
eventEntries = resolveEntries(
|
||||
eventTypeClass,
|
||||
listOf("UNKNOWN", "RESIZE", "KEY_DOWN", "KEY_UP")
|
||||
)
|
||||
keyCodeEntries = resolveEntries(
|
||||
keyCodeClass,
|
||||
listOf(
|
||||
"UNKNOWN", "CHARACTER", "ARROW_UP", "ARROW_DOWN", "ARROW_LEFT", "ARROW_RIGHT",
|
||||
"HOME", "END", "INSERT", "DELETE", "PAGE_UP", "PAGE_DOWN",
|
||||
"ESCAPE", "ENTER", "TAB", "BACKSPACE", "SPACE"
|
||||
)
|
||||
)
|
||||
ansiLevelEntries = resolveEntries(
|
||||
ansiLevelClass,
|
||||
listOf("NONE", "BASIC16", "ANSI256", "TRUECOLOR")
|
||||
)
|
||||
}
|
||||
|
||||
private fun resolveEnum(module: ModuleScope, enumName: String): ObjEnumClass {
|
||||
val local = module.get(enumName)?.value as? ObjEnumClass
|
||||
if (local != null) return local
|
||||
val root = module.importProvider.rootScope.get(enumName)?.value as? ObjEnumClass
|
||||
return root ?: error("lyng.io.console declaration enum is missing: $enumName")
|
||||
}
|
||||
|
||||
private fun resolveEntries(enumClass: ObjEnumClass, names: List<String>): Map<String, ObjEnumEntry> {
|
||||
return names.associateWith { name ->
|
||||
(enumClass.byName[ObjString(name)] as? ObjEnumEntry)
|
||||
?: error("lyng.io.console enum entry is missing: ${enumClass.className}.$name")
|
||||
}
|
||||
}
|
||||
|
||||
fun event(name: String): ObjEnumEntry = eventEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${eventTypeClass.className}.$name")
|
||||
|
||||
fun code(name: String): ObjEnumEntry = keyCodeEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${keyCodeClass.className}.$name")
|
||||
|
||||
fun ansiLevel(name: String): ObjEnumEntry = ansiLevelEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${ansiLevelClass.className}.$name")
|
||||
}
|
||||
|
||||
private val KEY_CODE_BY_KEY_NAME = mapOf(
|
||||
"ArrowUp" to "ARROW_UP",
|
||||
"ArrowDown" to "ARROW_DOWN",
|
||||
"ArrowLeft" to "ARROW_LEFT",
|
||||
"ArrowRight" to "ARROW_RIGHT",
|
||||
"Home" to "HOME",
|
||||
"End" to "END",
|
||||
"Insert" to "INSERT",
|
||||
"Delete" to "DELETE",
|
||||
"PageUp" to "PAGE_UP",
|
||||
"PageDown" to "PAGE_DOWN",
|
||||
"Escape" to "ESCAPE",
|
||||
"Enter" to "ENTER",
|
||||
"Tab" to "TAB",
|
||||
"Backspace" to "BACKSPACE",
|
||||
" " to "SPACE",
|
||||
)
|
||||
|
||||
private fun codeFrom(key: String, codeName: String?): ObjEnumEntry {
|
||||
val resolved = KEY_CODE_BY_KEY_NAME[codeName ?: key]
|
||||
return when {
|
||||
resolved != null -> ConsoleEnums.code(resolved)
|
||||
key.length == 1 -> ConsoleEnums.CHARACTER
|
||||
else -> ConsoleEnums.CODE_UNKNOWN
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class ObjConsoleEventBase(
|
||||
private val eventType: String,
|
||||
private val type: ObjEnumEntry,
|
||||
final override val objClass: net.sergeych.lyng.obj.ObjClass,
|
||||
) : Obj() {
|
||||
fun eventTypeName(): String = eventType
|
||||
fun type(): ObjEnumEntry = type
|
||||
}
|
||||
|
||||
private class ObjConsoleEvent : ObjConsoleEventBase("event", type) {
|
||||
private class ObjConsoleEvent : ObjConsoleEventBase(ConsoleEnums.UNKNOWN, type) {
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
|
||||
addPropertyDoc(
|
||||
name = "type",
|
||||
doc = "Event type string: resize, keydown, keyup.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { ObjString((this.thisObj as ObjConsoleEventBase).eventTypeName()) }
|
||||
)
|
||||
addProperty(name = "type", getter = { (this.thisObj as ObjConsoleEventBase).type() })
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -450,83 +459,40 @@ private class ObjConsoleEvent : ObjConsoleEventBase("event", type) {
|
||||
private class ObjConsoleResizeEvent(
|
||||
val columns: Int,
|
||||
val rows: Int,
|
||||
) : ObjConsoleEventBase("resize", type) {
|
||||
) : ObjConsoleEventBase(ConsoleEnums.RESIZE, type) {
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
|
||||
addPropertyDoc(
|
||||
name = "columns",
|
||||
doc = "Terminal width in character cells.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "rows",
|
||||
doc = "Terminal height in character cells.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() }
|
||||
)
|
||||
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() })
|
||||
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleKeyEvent(
|
||||
type: String,
|
||||
type: ObjEnumEntry,
|
||||
val key: String,
|
||||
val code: String?,
|
||||
val codeName: String?,
|
||||
val ctrl: Boolean,
|
||||
val alt: Boolean,
|
||||
val shift: Boolean,
|
||||
val meta: Boolean,
|
||||
) : ObjConsoleEventBase(type, typeObj) {
|
||||
init {
|
||||
require(key.isNotEmpty()) { "ConsoleKeyEvent.key must never be empty" }
|
||||
}
|
||||
|
||||
companion object {
|
||||
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
|
||||
addPropertyDoc(
|
||||
name = "key",
|
||||
doc = "Logical key name (e.g. ArrowLeft, a, Escape).",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "code",
|
||||
doc = "Optional hardware/code identifier.",
|
||||
type = type("lyng.String", nullable = true),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = {
|
||||
val code = (this.thisObj as ObjConsoleKeyEvent).code
|
||||
code?.let(::ObjString) ?: ObjNull
|
||||
}
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "ctrl",
|
||||
doc = "Whether Ctrl modifier is pressed.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "alt",
|
||||
doc = "Whether Alt modifier is pressed.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "shift",
|
||||
doc = "Whether Shift modifier is pressed.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "meta",
|
||||
doc = "Whether Meta/Super modifier is pressed.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() }
|
||||
)
|
||||
addProperty(name = "key", getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) })
|
||||
addProperty(name = "code", getter = { codeFrom((this.thisObj as ObjConsoleKeyEvent).key, (this.thisObj as ObjConsoleKeyEvent).codeName) })
|
||||
addProperty(name = "codeName", getter = {
|
||||
val code = (this.thisObj as ObjConsoleKeyEvent).codeName
|
||||
code?.let(::ObjString) ?: ObjNull
|
||||
})
|
||||
addProperty(name = "ctrl", getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() })
|
||||
addProperty(name = "alt", getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() })
|
||||
addProperty(name = "shift", getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() })
|
||||
addProperty(name = "meta", getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -539,20 +505,8 @@ private class ObjConsoleGeometry(
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply {
|
||||
addPropertyDoc(
|
||||
name = "columns",
|
||||
doc = "Terminal width in character cells.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "rows",
|
||||
doc = "Terminal height in character cells.",
|
||||
type = type("lyng.Int"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() }
|
||||
)
|
||||
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() })
|
||||
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -560,41 +514,17 @@ private class ObjConsoleGeometry(
|
||||
private class ObjConsoleDetails(
|
||||
val supported: Boolean,
|
||||
val isTty: Boolean,
|
||||
val ansiLevel: String,
|
||||
val ansiLevel: ObjEnumEntry,
|
||||
val geometry: ObjConsoleGeometry?,
|
||||
) : Obj() {
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply {
|
||||
addPropertyDoc(
|
||||
name = "supported",
|
||||
doc = "Whether console API is supported.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "isTty",
|
||||
doc = "Whether output is connected to a TTY.",
|
||||
type = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "ansiLevel",
|
||||
doc = "Detected ANSI color capability level.",
|
||||
type = type("lyng.String"),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { ObjString((this.thisObj as ObjConsoleDetails).ansiLevel) }
|
||||
)
|
||||
addPropertyDoc(
|
||||
name = "geometry",
|
||||
doc = "Current terminal geometry or null.",
|
||||
type = type("ConsoleGeometry", nullable = true),
|
||||
moduleName = "lyng.io.console",
|
||||
getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull }
|
||||
)
|
||||
addProperty(name = "supported", getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() })
|
||||
addProperty(name = "isTty", getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() })
|
||||
addProperty(name = "ansiLevel", getter = { (this.thisObj as ObjConsoleDetails).ansiLevel })
|
||||
addProperty(name = "geometry", getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull })
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.http
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjBuffer
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjImmutableMap
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjList
|
||||
import net.sergeych.lyng.obj.ObjMap
|
||||
import net.sergeych.lyng.obj.ObjMapEntry
|
||||
import net.sergeych.lyng.obj.ObjNull
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.requiredArg
|
||||
import net.sergeych.lyng.obj.thisAs
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.raiseIllegalOperation
|
||||
import net.sergeych.lyng.requireNoArgs
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyngio.http.LyngHttpRequest
|
||||
import net.sergeych.lyngio.http.LyngHttpResponse
|
||||
import net.sergeych.lyngio.http.getSystemHttpEngine
|
||||
import net.sergeych.lyngio.http.security.HttpAccessDeniedException
|
||||
import net.sergeych.lyngio.http.security.HttpAccessOp
|
||||
import net.sergeych.lyngio.http.security.HttpAccessPolicy
|
||||
import net.sergeych.lyngio.stdlib_included.httpLyng
|
||||
|
||||
private const val HTTP_MODULE_NAME = "lyng.io.http"
|
||||
|
||||
fun createHttpModule(policy: HttpAccessPolicy, scope: Scope): Boolean =
|
||||
createHttpModule(policy, scope.importManager)
|
||||
|
||||
fun createHttp(policy: HttpAccessPolicy, scope: Scope): Boolean = createHttpModule(policy, scope)
|
||||
|
||||
fun createHttpModule(policy: HttpAccessPolicy, manager: ImportManager): Boolean {
|
||||
if (manager.packageNames.contains(HTTP_MODULE_NAME)) return false
|
||||
manager.addPackage(HTTP_MODULE_NAME) { module ->
|
||||
buildHttpModule(module, policy)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun createHttp(policy: HttpAccessPolicy, manager: ImportManager): Boolean = createHttpModule(policy, manager)
|
||||
|
||||
private suspend fun buildHttpModule(module: ModuleScope, policy: HttpAccessPolicy) {
|
||||
module.eval(Source(HTTP_MODULE_NAME, httpLyng))
|
||||
val engine = getSystemHttpEngine()
|
||||
|
||||
val headersType = ObjHttpHeaders.type
|
||||
val requestType = ObjHttpRequest.type
|
||||
val responseType = ObjHttpResponse.type
|
||||
|
||||
val httpType = object : ObjClass("Http") {}
|
||||
httpType.addClassFn("isSupported") {
|
||||
ObjBool(engine.isSupported)
|
||||
}
|
||||
httpType.addClassFn("request") {
|
||||
httpGuard {
|
||||
val req = requiredArg<ObjHttpRequest>(0)
|
||||
val built = req.toRequest(this)
|
||||
policy.require(HttpAccessOp.Request(built.method, built.url))
|
||||
ObjHttpResponse.from(engine.request(built))
|
||||
}
|
||||
}
|
||||
httpType.addClassFn("get") {
|
||||
httpGuard {
|
||||
val url = requiredArg<ObjString>(0).value
|
||||
val headers = parseHeaderEntries(args.list.drop(1))
|
||||
policy.require(HttpAccessOp.Request("GET", url))
|
||||
ObjHttpResponse.from(engine.request(LyngHttpRequest(method = "GET", url = url, headers = headers)))
|
||||
}
|
||||
}
|
||||
httpType.addClassFn("post") {
|
||||
httpGuard {
|
||||
val url = requiredArg<ObjString>(0).value
|
||||
val bodyText = requiredArg<ObjString>(1).value
|
||||
val contentType = args.list.getOrNull(2)?.let { objOrNullToString(this, it) }
|
||||
val headers = parseHeaderEntries(args.list.drop(3)).toMutableMap()
|
||||
if (contentType != null && "Content-Type" !in headers) headers["Content-Type"] = contentType
|
||||
policy.require(HttpAccessOp.Request("POST", url))
|
||||
ObjHttpResponse.from(
|
||||
engine.request(
|
||||
LyngHttpRequest(method = "POST", url = url, headers = headers, bodyText = bodyText)
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
httpType.addClassFn("postBytes") {
|
||||
httpGuard {
|
||||
val url = requiredArg<ObjString>(0).value
|
||||
val body = requiredArg<ObjBuffer>(1).byteArray.toByteArray()
|
||||
val contentType = args.list.getOrNull(2)?.let { objOrNullToString(this, it) }
|
||||
val headers = parseHeaderEntries(args.list.drop(3)).toMutableMap()
|
||||
if (contentType != null && "Content-Type" !in headers) headers["Content-Type"] = contentType
|
||||
policy.require(HttpAccessOp.Request("POST", url))
|
||||
ObjHttpResponse.from(
|
||||
engine.request(
|
||||
LyngHttpRequest(method = "POST", url = url, headers = headers, bodyBytes = body)
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
module.addConst("Http", httpType)
|
||||
module.addConst("HttpHeaders", headersType)
|
||||
module.addConst("HttpRequest", requestType)
|
||||
module.addConst("HttpResponse", responseType)
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.httpGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: HttpAccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "http access denied")
|
||||
} catch (e: Exception) {
|
||||
raiseIllegalOperation(e.message ?: "http error")
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjHttpHeaders(
|
||||
singleValueHeaders: Map<String, String> = emptyMap(),
|
||||
private val allHeaders: Map<String, List<String>> = emptyMap(),
|
||||
) : Obj() {
|
||||
private val entries: LinkedHashMap<Obj, Obj> =
|
||||
LinkedHashMap(singleValueHeaders.entries.associate { ObjString(it.key) to ObjString(it.value) })
|
||||
|
||||
override val objClass: ObjClass
|
||||
get() = type
|
||||
|
||||
override suspend fun getAt(scope: Scope, index: Obj): Obj = findEntry(index)?.value ?: ObjNull
|
||||
|
||||
override suspend fun contains(scope: Scope, other: Obj): Boolean = findEntry(other) != null
|
||||
|
||||
override suspend fun defaultToString(scope: Scope): ObjString {
|
||||
val rendered = buildString {
|
||||
append("HttpHeaders(")
|
||||
var first = true
|
||||
for ((k, v) in entries) {
|
||||
if (!first) append(", ")
|
||||
append(k.toString(scope).value)
|
||||
append(" => ")
|
||||
append(v.toString(scope).value)
|
||||
first = false
|
||||
}
|
||||
append(")")
|
||||
}
|
||||
return ObjString(rendered)
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("HttpHeaders", ObjMap.type) {
|
||||
override suspend fun callOn(scope: Scope): Obj = ObjHttpHeaders()
|
||||
}.apply {
|
||||
addFn("get") {
|
||||
val self = thisAs<ObjHttpHeaders>()
|
||||
val name = requiredArg<ObjString>(0).value
|
||||
self.firstValue(name)?.let(::ObjString) ?: ObjNull
|
||||
}
|
||||
addFn("getAll") {
|
||||
val self = thisAs<ObjHttpHeaders>()
|
||||
val name = requiredArg<ObjString>(0).value
|
||||
ObjList(self.valuesOf(name).map(::ObjString).toMutableList())
|
||||
}
|
||||
addFn("names") {
|
||||
val self = thisAs<ObjHttpHeaders>()
|
||||
ObjList(self.allHeaders.keys.map(::ObjString).toMutableList())
|
||||
}
|
||||
addFn("getOrNull") {
|
||||
val self = thisAs<ObjHttpHeaders>()
|
||||
val name = requiredArg<ObjString>(0).value
|
||||
self.firstValue(name)?.let(::ObjString) ?: ObjNull
|
||||
}
|
||||
addProperty("size", getter = { ObjInt(thisAs<ObjHttpHeaders>().entries.size.toLong()) })
|
||||
addProperty("keys", getter = { ObjList(thisAs<ObjHttpHeaders>().entries.keys.toMutableList()) })
|
||||
addProperty("values", getter = { ObjList(thisAs<ObjHttpHeaders>().entries.values.toMutableList()) })
|
||||
addFn("iterator") {
|
||||
ObjList(
|
||||
thisAs<ObjHttpHeaders>().entries.map { (k, v) -> ObjMapEntry(k, v) }.toMutableList()
|
||||
).invokeInstanceMethod(requireScope(), "iterator")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun valuesOf(name: String): List<String> = allHeaders[lookupKey(name)] ?: emptyList()
|
||||
|
||||
private fun firstValue(name: String): String? = valuesOf(name).firstOrNull()
|
||||
|
||||
private fun lookupKey(name: String): String =
|
||||
allHeaders.keys.firstOrNull { it.equals(name, ignoreCase = true) } ?: name
|
||||
|
||||
private fun findEntry(index: Obj): Map.Entry<Obj, Obj>? {
|
||||
if (index is ObjString) {
|
||||
return entries.entries.firstOrNull { (k, _) ->
|
||||
(k as? ObjString)?.value?.equals(index.value, ignoreCase = true) == true
|
||||
}
|
||||
}
|
||||
return entries.entries.firstOrNull { it.key == index }
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjHttpRequest(
|
||||
var method: String = "GET",
|
||||
var url: String = "",
|
||||
val headers: MutableMap<String, String> = linkedMapOf(),
|
||||
var bodyText: String? = null,
|
||||
var bodyBytes: ByteArray? = null,
|
||||
var timeoutMillis: Long? = null,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type
|
||||
|
||||
suspend fun toRequest(scope: ScopeFacade): LyngHttpRequest {
|
||||
if (bodyText != null && bodyBytes != null) {
|
||||
scope.raiseIllegalArgument("Only one of bodyText or bodyBytes may be set")
|
||||
}
|
||||
return LyngHttpRequest(
|
||||
method = method,
|
||||
url = url,
|
||||
headers = LinkedHashMap(headers),
|
||||
bodyText = bodyText,
|
||||
bodyBytes = bodyBytes,
|
||||
timeoutMillis = timeoutMillis,
|
||||
)
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("HttpRequest") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
if (scope.args.list.isNotEmpty()) scope.raiseError("HttpRequest() does not accept arguments")
|
||||
return ObjHttpRequest()
|
||||
}
|
||||
}.apply {
|
||||
addProperty("method",
|
||||
getter = { ObjString(thisAs<ObjHttpRequest>().method) },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().method = objOrNullToString(this, value)
|
||||
?: raiseIllegalArgument("method cannot be null")
|
||||
}
|
||||
)
|
||||
addProperty("url",
|
||||
getter = { ObjString(thisAs<ObjHttpRequest>().url) },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().url = objOrNullToString(this, value)
|
||||
?: raiseIllegalArgument("url cannot be null")
|
||||
}
|
||||
)
|
||||
addProperty("headers",
|
||||
getter = { thisAs<ObjHttpRequest>().headers.toObjMap() },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().headers.clear()
|
||||
thisAs<ObjHttpRequest>().headers.putAll(mapObjToStrings(this, value))
|
||||
}
|
||||
)
|
||||
addProperty("bodyText",
|
||||
getter = { thisAs<ObjHttpRequest>().bodyText?.let(::ObjString) ?: ObjNull },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().bodyText = objOrNullToString(this, value)
|
||||
}
|
||||
)
|
||||
addProperty("bodyBytes",
|
||||
getter = { thisAs<ObjHttpRequest>().bodyBytes?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().bodyBytes = when (value) {
|
||||
ObjNull -> null
|
||||
is ObjBuffer -> value.byteArray.toByteArray()
|
||||
else -> raiseClassCastError("bodyBytes must be Buffer or null")
|
||||
}
|
||||
}
|
||||
)
|
||||
addProperty("timeoutMillis",
|
||||
getter = { thisAs<ObjHttpRequest>().timeoutMillis?.let { ObjInt(it) } ?: ObjNull },
|
||||
setter = { value ->
|
||||
thisAs<ObjHttpRequest>().timeoutMillis = when (value) {
|
||||
ObjNull -> null
|
||||
is ObjInt -> value.value
|
||||
else -> raiseClassCastError("timeoutMillis must be Int or null")
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjHttpResponse(
|
||||
val status: Long,
|
||||
val statusText: String,
|
||||
val headers: ObjHttpHeaders,
|
||||
private val bodyBytes: ByteArray,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("HttpResponse") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("HttpResponse cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addProperty("status", getter = { ObjInt(thisAs<ObjHttpResponse>().status) })
|
||||
addProperty("statusText", getter = { ObjString(thisAs<ObjHttpResponse>().statusText) })
|
||||
addProperty("headers", getter = { thisAs<ObjHttpResponse>().headers })
|
||||
addFn("text") {
|
||||
ObjString(thisAs<ObjHttpResponse>().bodyBytes.decodeToString())
|
||||
}
|
||||
addFn("bytes") {
|
||||
ObjBuffer(thisAs<ObjHttpResponse>().bodyBytes.toUByteArray())
|
||||
}
|
||||
}
|
||||
|
||||
fun from(response: LyngHttpResponse): ObjHttpResponse {
|
||||
val single = linkedMapOf<String, String>()
|
||||
response.headers.forEach { (name, values) ->
|
||||
if (values.isNotEmpty() && !single.containsKey(name)) {
|
||||
single[name] = values.first()
|
||||
}
|
||||
}
|
||||
return ObjHttpResponse(
|
||||
status = response.status.toLong(),
|
||||
statusText = response.statusText,
|
||||
headers = ObjHttpHeaders(singleValueHeaders = single, allHeaders = response.headers),
|
||||
bodyBytes = response.bodyBytes,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.parseHeaderEntries(values: List<Obj>): Map<String, String> {
|
||||
val out = linkedMapOf<String, String>()
|
||||
values.forEach { value ->
|
||||
when (value) {
|
||||
is ObjMapEntry -> {
|
||||
out[toStringOf(value.key).value] = toStringOf(value.value).value
|
||||
}
|
||||
else -> {
|
||||
if (!value.isInstanceOf(net.sergeych.lyng.obj.ObjArray)) {
|
||||
raiseIllegalArgument("headers entries must be MapEntry or [key, value]")
|
||||
}
|
||||
val size = (value.invokeInstanceMethod(requireScope(), "size") as ObjInt).value.toInt()
|
||||
if (size != 2) {
|
||||
raiseIllegalArgument("header entry array must contain exactly 2 items")
|
||||
}
|
||||
out[toStringOf(value.getAt(requireScope(), ObjInt.Zero)).value] =
|
||||
toStringOf(value.getAt(requireScope(), ObjInt.One)).value
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
private suspend fun mapObjToStrings(scope: ScopeFacade, value: Obj): MutableMap<String, String> {
|
||||
val entries = when (value) {
|
||||
is ObjMap -> value.map
|
||||
is ObjImmutableMap -> value.map
|
||||
ObjNull -> return linkedMapOf()
|
||||
else -> scope.raiseClassCastError("headers must be Map<String, String>")
|
||||
}
|
||||
return entries.entries.associateTo(linkedMapOf()) { (k, v) ->
|
||||
scope.toStringOf(k).value to scope.toStringOf(v).value
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj): String? = when (value) {
|
||||
ObjNull -> null
|
||||
else -> scope.toStringOf(value).value
|
||||
}
|
||||
|
||||
private fun Map<String, String>.toObjMap(): ObjMap =
|
||||
ObjMap(entries.associate { ObjString(it.key) to ObjString(it.value) }.toMutableMap())
|
||||
@@ -0,0 +1,376 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.net
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjBuffer
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjList
|
||||
import net.sergeych.lyng.obj.ObjNull
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.requiredArg
|
||||
import net.sergeych.lyng.obj.thisAs
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.raiseIllegalOperation
|
||||
import net.sergeych.lyng.requireNoArgs
|
||||
import net.sergeych.lyngio.net.LyngDatagram
|
||||
import net.sergeych.lyngio.net.LyngIpVersion
|
||||
import net.sergeych.lyngio.net.LyngNetEngine
|
||||
import net.sergeych.lyngio.net.LyngSocketAddress
|
||||
import net.sergeych.lyngio.net.LyngTcpServer
|
||||
import net.sergeych.lyngio.net.LyngTcpSocket
|
||||
import net.sergeych.lyngio.net.LyngUdpSocket
|
||||
import net.sergeych.lyngio.net.getSystemNetEngine
|
||||
import net.sergeych.lyngio.net.security.NetAccessDeniedException
|
||||
import net.sergeych.lyngio.net.security.NetAccessOp
|
||||
import net.sergeych.lyngio.net.security.NetAccessPolicy
|
||||
import net.sergeych.lyngio.stdlib_included.netLyng
|
||||
|
||||
private const val NET_MODULE_NAME = "lyng.io.net"
|
||||
|
||||
fun createNetModule(policy: NetAccessPolicy, scope: Scope): Boolean =
|
||||
createNetModule(policy, scope.importManager)
|
||||
|
||||
fun createNet(policy: NetAccessPolicy, scope: Scope): Boolean = createNetModule(policy, scope)
|
||||
|
||||
fun createNetModule(policy: NetAccessPolicy, manager: ImportManager): Boolean {
|
||||
if (manager.packageNames.contains(NET_MODULE_NAME)) return false
|
||||
manager.addPackage(NET_MODULE_NAME) { module ->
|
||||
buildNetModule(module, policy)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun createNet(policy: NetAccessPolicy, manager: ImportManager): Boolean = createNetModule(policy, manager)
|
||||
|
||||
private suspend fun buildNetModule(module: ModuleScope, policy: NetAccessPolicy) {
|
||||
module.eval(Source(NET_MODULE_NAME, netLyng))
|
||||
val engine = getSystemNetEngine()
|
||||
val enumValues = NetEnumValues.load(module)
|
||||
|
||||
val netType = object : ObjClass("Net") {}
|
||||
netType.addClassFn("isSupported") { ObjBool(engine.isSupported) }
|
||||
netType.addClassFn("isTcpAvailable") { ObjBool(engine.isTcpAvailable) }
|
||||
netType.addClassFn("isTcpServerAvailable") { ObjBool(engine.isTcpServerAvailable) }
|
||||
netType.addClassFn("isUdpAvailable") { ObjBool(engine.isUdpAvailable) }
|
||||
netType.addClassFn("resolve") {
|
||||
netGuard {
|
||||
val host = requiredArg<ObjString>(0).value
|
||||
val port = requirePort(requiredArg<ObjInt>(1).value)
|
||||
policy.require(NetAccessOp.Resolve(host, port))
|
||||
ObjList(engine.resolve(host, port).map { ObjSocketAddress(it, enumValues) }.toMutableList())
|
||||
}
|
||||
}
|
||||
netType.addClassFn("tcpConnect") {
|
||||
netGuard {
|
||||
val host = requiredArg<ObjString>(0).value
|
||||
val port = requirePort(requiredArg<ObjInt>(1).value)
|
||||
val timeoutMillis = args.list.getOrNull(2)?.let { objOrNullToLong(this, it, "timeoutMillis") }
|
||||
val noDelay = args.list.getOrNull(3)?.let { objToBool(this, it, "noDelay") } ?: true
|
||||
policy.require(NetAccessOp.TcpConnect(host, port))
|
||||
ObjTcpSocket(engine.tcpConnect(host, port, timeoutMillis, noDelay), enumValues)
|
||||
}
|
||||
}
|
||||
netType.addClassFn("tcpListen") {
|
||||
netGuard {
|
||||
val port = requirePort(requiredArg<ObjInt>(0).value)
|
||||
val host = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "host") }
|
||||
val backlog = args.list.getOrNull(2)?.let { objToInt(this, it, "backlog") } ?: 128
|
||||
requirePositive(backlog, "backlog")
|
||||
val reuseAddress = args.list.getOrNull(3)?.let { objToBool(this, it, "reuseAddress") } ?: true
|
||||
policy.require(NetAccessOp.TcpListen(host, port, backlog))
|
||||
ObjTcpServer(engine.tcpListen(host, port, backlog, reuseAddress), enumValues)
|
||||
}
|
||||
}
|
||||
netType.addClassFn("udpBind") {
|
||||
netGuard {
|
||||
val port = args.list.getOrNull(0)?.let { objToInt(this, it, "port") } ?: 0
|
||||
requirePort(port)
|
||||
val host = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "host") }
|
||||
val reuseAddress = args.list.getOrNull(2)?.let { objToBool(this, it, "reuseAddress") } ?: true
|
||||
policy.require(NetAccessOp.UdpBind(host, port))
|
||||
ObjUdpSocket(engine.udpBind(host, port, reuseAddress), enumValues)
|
||||
}
|
||||
}
|
||||
|
||||
module.addConst("Net", netType)
|
||||
module.addConst("SocketAddress", ObjSocketAddress.type(enumValues))
|
||||
module.addConst("Datagram", ObjDatagram.type(enumValues))
|
||||
module.addConst("TcpSocket", ObjTcpSocket.type(enumValues))
|
||||
module.addConst("TcpServer", ObjTcpServer.type(enumValues))
|
||||
module.addConst("UdpSocket", ObjUdpSocket.type(enumValues))
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.netGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: NetAccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "network access denied")
|
||||
} catch (e: Exception) {
|
||||
raiseIllegalOperation(e.message ?: "network error")
|
||||
}
|
||||
}
|
||||
|
||||
private class NetEnumValues(
|
||||
val ipv4: Obj,
|
||||
val ipv6: Obj,
|
||||
) {
|
||||
fun of(version: LyngIpVersion): Obj = when (version) {
|
||||
LyngIpVersion.IPV4 -> ipv4
|
||||
LyngIpVersion.IPV6 -> ipv6
|
||||
}
|
||||
|
||||
companion object {
|
||||
suspend fun load(module: ModuleScope): NetEnumValues {
|
||||
val ipVersionClass = module["IpVersion"]?.value as? ObjClass
|
||||
?: error("lyng.io.net.IpVersion is missing after declaration load")
|
||||
return NetEnumValues(
|
||||
ipv4 = ipVersionClass.readField(module, "IPV4").value,
|
||||
ipv6 = ipVersionClass.readField(module, "IPV6").value,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjSocketAddress(
|
||||
private val address: LyngSocketAddress,
|
||||
private val enumValues: NetEnumValues,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type(enumValues)
|
||||
|
||||
override suspend fun defaultToString(scope: Scope): ObjString = ObjString(renderAddress(address))
|
||||
|
||||
companion object {
|
||||
private val types = mutableMapOf<NetEnumValues, ObjClass>()
|
||||
|
||||
fun type(enumValues: NetEnumValues): ObjClass =
|
||||
types.getOrPut(enumValues) {
|
||||
object : ObjClass("SocketAddress") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("SocketAddress cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addProperty("host", getter = { ObjString(thisAs<ObjSocketAddress>().address.host) })
|
||||
addProperty("port", getter = { ObjInt(thisAs<ObjSocketAddress>().address.port.toLong()) })
|
||||
addProperty("ipVersion", getter = { enumValues.of(thisAs<ObjSocketAddress>().address.ipVersion) })
|
||||
addProperty("resolved", getter = { ObjBool(thisAs<ObjSocketAddress>().address.resolved) })
|
||||
addFn("toString") { ObjString(renderAddress(thisAs<ObjSocketAddress>().address)) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjDatagram(
|
||||
private val datagram: LyngDatagram,
|
||||
private val enumValues: NetEnumValues,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type(enumValues)
|
||||
|
||||
companion object {
|
||||
private val types = mutableMapOf<NetEnumValues, ObjClass>()
|
||||
|
||||
fun type(enumValues: NetEnumValues): ObjClass =
|
||||
types.getOrPut(enumValues) {
|
||||
object : ObjClass("Datagram") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("Datagram cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addProperty("data", getter = {
|
||||
ObjBuffer(thisAs<ObjDatagram>().datagram.data.toUByteArray())
|
||||
})
|
||||
addProperty("address", getter = {
|
||||
ObjSocketAddress(thisAs<ObjDatagram>().datagram.address, enumValues)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjTcpSocket(
|
||||
private val socket: LyngTcpSocket,
|
||||
private val enumValues: NetEnumValues,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type(enumValues)
|
||||
|
||||
companion object {
|
||||
private val types = mutableMapOf<NetEnumValues, ObjClass>()
|
||||
|
||||
fun type(enumValues: NetEnumValues): ObjClass =
|
||||
types.getOrPut(enumValues) {
|
||||
object : ObjClass("TcpSocket") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("TcpSocket cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addFn("isOpen") { ObjBool(thisAs<ObjTcpSocket>().socket.isOpen()) }
|
||||
addFn("localAddress") { ObjSocketAddress(thisAs<ObjTcpSocket>().socket.localAddress(), enumValues) }
|
||||
addFn("remoteAddress") { ObjSocketAddress(thisAs<ObjTcpSocket>().socket.remoteAddress(), enumValues) }
|
||||
addFn("read") {
|
||||
val maxBytes = args.list.getOrNull(0)?.let { objToInt(this, it, "maxBytes") } ?: 65536
|
||||
requirePositive(maxBytes, "maxBytes")
|
||||
thisAs<ObjTcpSocket>().socket.read(maxBytes)?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull
|
||||
}
|
||||
addFn("readLine") {
|
||||
thisAs<ObjTcpSocket>().socket.readLine()?.let(::ObjString) ?: ObjNull
|
||||
}
|
||||
addFn("write") {
|
||||
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
|
||||
thisAs<ObjTcpSocket>().socket.write(data)
|
||||
ObjVoid
|
||||
}
|
||||
addFn("writeUtf8") {
|
||||
val text = requiredArg<ObjString>(0).value
|
||||
thisAs<ObjTcpSocket>().socket.writeUtf8(text)
|
||||
ObjVoid
|
||||
}
|
||||
addFn("flush") {
|
||||
requireNoArgs()
|
||||
thisAs<ObjTcpSocket>().socket.flush()
|
||||
ObjVoid
|
||||
}
|
||||
addFn("close") {
|
||||
requireNoArgs()
|
||||
thisAs<ObjTcpSocket>().socket.close()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjTcpServer(
|
||||
private val server: LyngTcpServer,
|
||||
private val enumValues: NetEnumValues,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type(enumValues)
|
||||
|
||||
companion object {
|
||||
private val types = mutableMapOf<NetEnumValues, ObjClass>()
|
||||
|
||||
fun type(enumValues: NetEnumValues): ObjClass =
|
||||
types.getOrPut(enumValues) {
|
||||
object : ObjClass("TcpServer") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("TcpServer cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addFn("isOpen") { ObjBool(thisAs<ObjTcpServer>().server.isOpen()) }
|
||||
addFn("localAddress") { ObjSocketAddress(thisAs<ObjTcpServer>().server.localAddress(), enumValues) }
|
||||
addFn("accept") {
|
||||
ObjTcpSocket(thisAs<ObjTcpServer>().server.accept(), enumValues)
|
||||
}
|
||||
addFn("close") {
|
||||
requireNoArgs()
|
||||
thisAs<ObjTcpServer>().server.close()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjUdpSocket(
|
||||
private val socket: LyngUdpSocket,
|
||||
private val enumValues: NetEnumValues,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type(enumValues)
|
||||
|
||||
companion object {
|
||||
private val types = mutableMapOf<NetEnumValues, ObjClass>()
|
||||
|
||||
fun type(enumValues: NetEnumValues): ObjClass =
|
||||
types.getOrPut(enumValues) {
|
||||
object : ObjClass("UdpSocket") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("UdpSocket cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addFn("isOpen") { ObjBool(thisAs<ObjUdpSocket>().socket.isOpen()) }
|
||||
addFn("localAddress") { ObjSocketAddress(thisAs<ObjUdpSocket>().socket.localAddress(), enumValues) }
|
||||
addFn("receive") {
|
||||
val maxBytes = args.list.getOrNull(0)?.let { objToInt(this, it, "maxBytes") } ?: 65536
|
||||
requirePositive(maxBytes, "maxBytes")
|
||||
thisAs<ObjUdpSocket>().socket.receive(maxBytes)?.let { ObjDatagram(it, enumValues) } ?: ObjNull
|
||||
}
|
||||
addFn("send") {
|
||||
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
|
||||
val host = requiredArg<ObjString>(1).value
|
||||
val port = requirePort(requiredArg<ObjInt>(2).value)
|
||||
thisAs<ObjUdpSocket>().socket.send(data, host, port)
|
||||
ObjVoid
|
||||
}
|
||||
addFn("close") {
|
||||
requireNoArgs()
|
||||
thisAs<ObjUdpSocket>().socket.close()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun renderAddress(address: LyngSocketAddress): String =
|
||||
if (address.ipVersion == LyngIpVersion.IPV6) "[${address.host}]:${address.port}" else "${address.host}:${address.port}"
|
||||
|
||||
private fun ScopeFacade.requirePort(value: Long): Int {
|
||||
if (value !in 0..65535) raiseIllegalArgument("port must be in 0..65535")
|
||||
return value.toInt()
|
||||
}
|
||||
|
||||
private fun ScopeFacade.requirePort(value: Int): Int {
|
||||
if (value !in 0..65535) raiseIllegalArgument("port must be in 0..65535")
|
||||
return value
|
||||
}
|
||||
|
||||
private fun ScopeFacade.requirePositive(value: Int, name: String) {
|
||||
if (value <= 0) raiseIllegalArgument("$name must be positive")
|
||||
}
|
||||
|
||||
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj, name: String): String? = when (value) {
|
||||
ObjNull -> null
|
||||
else -> scope.toStringOf(value).value
|
||||
}
|
||||
|
||||
private fun objToInt(scope: ScopeFacade, value: Obj, name: String): Int = when (value) {
|
||||
is ObjInt -> value.value.toInt()
|
||||
else -> scope.raiseClassCastError("$name must be Int")
|
||||
}
|
||||
|
||||
private fun objToBool(scope: ScopeFacade, value: Obj, name: String): Boolean = when (value) {
|
||||
is ObjBool -> value.value
|
||||
else -> scope.raiseClassCastError("$name must be Bool")
|
||||
}
|
||||
|
||||
private fun objOrNullToLong(scope: ScopeFacade, value: Obj, name: String): Long? = when (value) {
|
||||
ObjNull -> null
|
||||
is ObjInt -> value.value
|
||||
else -> scope.raiseClassCastError("$name must be Int or null")
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.ws
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjBuffer
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjMapEntry
|
||||
import net.sergeych.lyng.obj.ObjNull
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.requiredArg
|
||||
import net.sergeych.lyng.obj.thisAs
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.raiseIllegalOperation
|
||||
import net.sergeych.lyng.requireNoArgs
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyngio.stdlib_included.wsLyng
|
||||
import net.sergeych.lyngio.ws.LyngWsEngine
|
||||
import net.sergeych.lyngio.ws.LyngWsMessage
|
||||
import net.sergeych.lyngio.ws.LyngWsSession
|
||||
import net.sergeych.lyngio.ws.getSystemWsEngine
|
||||
import net.sergeych.lyngio.ws.security.WsAccessDeniedException
|
||||
import net.sergeych.lyngio.ws.security.WsAccessOp
|
||||
import net.sergeych.lyngio.ws.security.WsAccessPolicy
|
||||
|
||||
private const val WS_MODULE_NAME = "lyng.io.ws"
|
||||
|
||||
fun createWsModule(policy: WsAccessPolicy, scope: Scope): Boolean =
|
||||
createWsModule(policy, scope.importManager)
|
||||
|
||||
fun createWs(policy: WsAccessPolicy, scope: Scope): Boolean = createWsModule(policy, scope)
|
||||
|
||||
fun createWsModule(policy: WsAccessPolicy, manager: ImportManager): Boolean {
|
||||
if (manager.packageNames.contains(WS_MODULE_NAME)) return false
|
||||
manager.addPackage(WS_MODULE_NAME) { module ->
|
||||
buildWsModule(module, policy)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun createWs(policy: WsAccessPolicy, manager: ImportManager): Boolean = createWsModule(policy, manager)
|
||||
|
||||
private suspend fun buildWsModule(module: ModuleScope, policy: WsAccessPolicy) {
|
||||
module.eval(Source(WS_MODULE_NAME, wsLyng))
|
||||
val engine = getSystemWsEngine()
|
||||
|
||||
val wsType = object : ObjClass("Ws") {}
|
||||
wsType.addClassFn("isSupported") { ObjBool(engine.isSupported) }
|
||||
wsType.addClassFn("connect") {
|
||||
wsGuard {
|
||||
val url = requiredArg<ObjString>(0).value
|
||||
val headers = parseHeaderEntries(args.list.drop(1))
|
||||
policy.require(WsAccessOp.Connect(url))
|
||||
ObjWsSession(url, engine.connect(url, headers), policy)
|
||||
}
|
||||
}
|
||||
|
||||
module.addConst("Ws", wsType)
|
||||
module.addConst("WsMessage", ObjWsMessage.type)
|
||||
module.addConst("WsSession", ObjWsSession.type)
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.wsGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: WsAccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "websocket access denied")
|
||||
} catch (e: Exception) {
|
||||
raiseIllegalOperation(e.message ?: "websocket error")
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjWsMessage(
|
||||
private val message: LyngWsMessage,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("WsMessage") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("WsMessage cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addProperty("isText", getter = { ObjBool(thisAs<ObjWsMessage>().message.isText) })
|
||||
addProperty("text", getter = {
|
||||
thisAs<ObjWsMessage>().message.text?.let(::ObjString) ?: ObjNull
|
||||
})
|
||||
addProperty("data", getter = {
|
||||
thisAs<ObjWsMessage>().message.data?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjWsSession(
|
||||
private val targetUrl: String,
|
||||
private val session: LyngWsSession,
|
||||
private val policy: WsAccessPolicy,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass
|
||||
get() = type
|
||||
|
||||
companion object {
|
||||
val type = object : ObjClass("WsSession") {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
scope.raiseError("WsSession cannot be created directly")
|
||||
}
|
||||
}.apply {
|
||||
addFn("isOpen") {
|
||||
ObjBool(thisAs<ObjWsSession>().session.isOpen())
|
||||
}
|
||||
addFn("url") {
|
||||
ObjString(thisAs<ObjWsSession>().targetUrl)
|
||||
}
|
||||
addFn("sendText") {
|
||||
val self = thisAs<ObjWsSession>()
|
||||
val text = requiredArg<ObjString>(0).value
|
||||
self.policy.require(WsAccessOp.Send(self.targetUrl, text.encodeToByteArray().size, isText = true))
|
||||
self.session.sendText(text)
|
||||
ObjVoid
|
||||
}
|
||||
addFn("sendBytes") {
|
||||
val self = thisAs<ObjWsSession>()
|
||||
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
|
||||
self.policy.require(WsAccessOp.Send(self.targetUrl, data.size, isText = false))
|
||||
self.session.sendBytes(data)
|
||||
ObjVoid
|
||||
}
|
||||
addFn("receive") {
|
||||
val self = thisAs<ObjWsSession>()
|
||||
self.policy.require(WsAccessOp.Receive(self.targetUrl))
|
||||
self.session.receive()?.let(::ObjWsMessage) ?: ObjNull
|
||||
}
|
||||
addFn("close") {
|
||||
val self = thisAs<ObjWsSession>()
|
||||
val code = args.list.getOrNull(0)?.let { objToInt(this, it, "code") } ?: 1000
|
||||
val reason = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "reason") } ?: ""
|
||||
self.session.close(code, reason)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.parseHeaderEntries(values: List<Obj>): Map<String, String> {
|
||||
val out = linkedMapOf<String, String>()
|
||||
values.forEach { value ->
|
||||
when (value) {
|
||||
is ObjMapEntry -> {
|
||||
out[toStringOf(value.key).value] = toStringOf(value.value).value
|
||||
}
|
||||
else -> {
|
||||
if (!value.isInstanceOf(net.sergeych.lyng.obj.ObjArray)) {
|
||||
raiseIllegalArgument("headers entries must be MapEntry or [key, value]")
|
||||
}
|
||||
val size = (value.invokeInstanceMethod(requireScope(), "size") as ObjInt).value.toInt()
|
||||
if (size != 2) {
|
||||
raiseIllegalArgument("header entry array must contain exactly 2 items")
|
||||
}
|
||||
out[toStringOf(value.getAt(requireScope(), ObjInt.Zero)).value] =
|
||||
toStringOf(value.getAt(requireScope(), ObjInt.One)).value
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj, name: String): String? = when (value) {
|
||||
ObjNull -> null
|
||||
else -> scope.toStringOf(value).value
|
||||
}
|
||||
|
||||
private fun objToInt(scope: ScopeFacade, value: Obj, name: String): Int = when (value) {
|
||||
is ObjInt -> value.value.toInt()
|
||||
else -> scope.raiseClassCastError("$name must be Int")
|
||||
}
|
||||
@@ -100,8 +100,9 @@ object MordantLyngConsole : LyngConsole {
|
||||
var running = true
|
||||
|
||||
globalLaunch {
|
||||
var lastWidth = t.updateSize().width
|
||||
var lastHeight = t.updateSize().height
|
||||
val initialSize = runCatching { t.updateSize() }.getOrNull()
|
||||
var lastWidth = initialSize?.width ?: 0
|
||||
var lastHeight = initialSize?.height ?: 0
|
||||
val startMark = TimeSource.Monotonic.markNow()
|
||||
var lastHeartbeatMark = startMark
|
||||
var loops = 0L
|
||||
@@ -113,6 +114,18 @@ object MordantLyngConsole : LyngConsole {
|
||||
var lastKeyMark = startMark
|
||||
var lastRawRecoveryMark = startMark
|
||||
|
||||
fun tryEmitResize(width: Int, height: Int) {
|
||||
if (width < 1 || height < 1) {
|
||||
consoleFlowDebug("events: ignored invalid resize width=$width height=$height")
|
||||
return
|
||||
}
|
||||
if (width == lastWidth && height == lastHeight) return
|
||||
out.trySend(ConsoleEvent.Resize(width, height))
|
||||
lastWidth = width
|
||||
lastHeight = height
|
||||
resizeEvents += 1
|
||||
}
|
||||
|
||||
consoleFlowDebug("events: collector started")
|
||||
try {
|
||||
while (currentCoroutineContext().isActive && sourceState.withLock { running }) {
|
||||
@@ -122,12 +135,7 @@ object MordantLyngConsole : LyngConsole {
|
||||
delay(150)
|
||||
continue
|
||||
}
|
||||
if (currentSize.width != lastWidth || currentSize.height != lastHeight) {
|
||||
out.trySend(ConsoleEvent.Resize(currentSize.width, currentSize.height))
|
||||
lastWidth = currentSize.width
|
||||
lastHeight = currentSize.height
|
||||
resizeEvents += 1
|
||||
}
|
||||
tryEmitResize(currentSize.width, currentSize.height)
|
||||
|
||||
val raw = stateMutex.withLock {
|
||||
if (!rawModeRequested) {
|
||||
@@ -173,10 +181,8 @@ object MordantLyngConsole : LyngConsole {
|
||||
val ev = readResult.getOrNull()
|
||||
|
||||
val resized = runCatching { t.updateSize() }.getOrNull()
|
||||
if (resized != null && (resized.width != lastWidth || resized.height != lastHeight)) {
|
||||
out.trySend(ConsoleEvent.Resize(resized.width, resized.height))
|
||||
lastWidth = resized.width
|
||||
lastHeight = resized.height
|
||||
if (resized != null) {
|
||||
tryEmitResize(resized.width, resized.height)
|
||||
}
|
||||
|
||||
when (ev) {
|
||||
|
||||
@@ -17,248 +17,12 @@
|
||||
|
||||
package net.sergeych.lyngio.docs
|
||||
|
||||
import net.sergeych.lyng.miniast.BuiltinDocRegistry
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
|
||||
/**
|
||||
* Console docs are declared in `lyngio/stdlib/lyng/io/console.lyng`.
|
||||
* Keep this shim for compatibility with reflective loaders.
|
||||
*/
|
||||
object ConsoleBuiltinDocs {
|
||||
private var registered = false
|
||||
|
||||
fun ensure() {
|
||||
if (registered) return
|
||||
BuiltinDocRegistry.module("lyng.io.console") {
|
||||
classDoc(
|
||||
name = "Console",
|
||||
doc = "Console runtime API."
|
||||
) {
|
||||
method(
|
||||
name = "isSupported",
|
||||
doc = "Whether console control API is supported on this platform.",
|
||||
returns = type("lyng.Bool"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "isTty",
|
||||
doc = "Whether stdout is attached to an interactive TTY.",
|
||||
returns = type("lyng.Bool"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "ansiLevel",
|
||||
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
|
||||
returns = type("lyng.String"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "geometry",
|
||||
doc = "Current terminal geometry or null.",
|
||||
returns = type("ConsoleGeometry", nullable = true),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "details",
|
||||
doc = "Get consolidated console details.",
|
||||
returns = type("ConsoleDetails"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "write",
|
||||
doc = "Write text directly to console output.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String"))),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "flush",
|
||||
doc = "Flush console output buffer.",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "home",
|
||||
doc = "Move cursor to home position (1,1).",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "clear",
|
||||
doc = "Clear the visible screen buffer.",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "moveTo",
|
||||
doc = "Move cursor to 1-based row and column.",
|
||||
params = listOf(
|
||||
ParamDoc("row", type("lyng.Int")),
|
||||
ParamDoc("column", type("lyng.Int")),
|
||||
),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "clearLine",
|
||||
doc = "Clear the current line.",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "enterAltScreen",
|
||||
doc = "Switch to terminal alternate screen buffer.",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "leaveAltScreen",
|
||||
doc = "Return from alternate screen buffer to normal screen.",
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "setCursorVisible",
|
||||
doc = "Show or hide the terminal cursor.",
|
||||
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "events",
|
||||
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
|
||||
returns = type("ConsoleEventStream"),
|
||||
isStatic = true
|
||||
)
|
||||
method(
|
||||
name = "setRawMode",
|
||||
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
|
||||
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
|
||||
returns = type("lyng.Bool"),
|
||||
isStatic = true
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleEventStream",
|
||||
doc = "Endless iterable stream of console events."
|
||||
) {
|
||||
method(
|
||||
name = "iterator",
|
||||
doc = "Create an iterator over incoming console events.",
|
||||
returns = type("lyng.Iterator")
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleGeometry",
|
||||
doc = "Terminal geometry."
|
||||
) {
|
||||
field(
|
||||
name = "columns",
|
||||
doc = "Terminal width in character cells.",
|
||||
type = type("lyng.Int")
|
||||
)
|
||||
field(
|
||||
name = "rows",
|
||||
doc = "Terminal height in character cells.",
|
||||
type = type("lyng.Int")
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleDetails",
|
||||
doc = "Consolidated console capability details."
|
||||
) {
|
||||
field(
|
||||
name = "supported",
|
||||
doc = "Whether console API is supported.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
field(
|
||||
name = "isTty",
|
||||
doc = "Whether output is attached to a TTY.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
field(
|
||||
name = "ansiLevel",
|
||||
doc = "Detected ANSI color capability.",
|
||||
type = type("lyng.String")
|
||||
)
|
||||
field(
|
||||
name = "geometry",
|
||||
doc = "Current geometry or null.",
|
||||
type = type("ConsoleGeometry", nullable = true)
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleEvent",
|
||||
doc = "Base class for console events."
|
||||
) {
|
||||
field(
|
||||
name = "type",
|
||||
doc = "Event kind string.",
|
||||
type = type("lyng.String")
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleResizeEvent",
|
||||
doc = "Resize event."
|
||||
) {
|
||||
field(
|
||||
name = "type",
|
||||
doc = "Event kind string: resize.",
|
||||
type = type("lyng.String")
|
||||
)
|
||||
field(
|
||||
name = "columns",
|
||||
doc = "Terminal width in character cells.",
|
||||
type = type("lyng.Int")
|
||||
)
|
||||
field(
|
||||
name = "rows",
|
||||
doc = "Terminal height in character cells.",
|
||||
type = type("lyng.Int")
|
||||
)
|
||||
}
|
||||
classDoc(
|
||||
name = "ConsoleKeyEvent",
|
||||
doc = "Keyboard event."
|
||||
) {
|
||||
field(
|
||||
name = "type",
|
||||
doc = "Event kind string: keydown or keyup.",
|
||||
type = type("lyng.String")
|
||||
)
|
||||
field(
|
||||
name = "key",
|
||||
doc = "Logical key name.",
|
||||
type = type("lyng.String")
|
||||
)
|
||||
field(
|
||||
name = "code",
|
||||
doc = "Optional hardware code.",
|
||||
type = type("lyng.String", nullable = true)
|
||||
)
|
||||
field(
|
||||
name = "ctrl",
|
||||
doc = "Ctrl modifier state.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
field(
|
||||
name = "alt",
|
||||
doc = "Alt modifier state.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
field(
|
||||
name = "shift",
|
||||
doc = "Shift modifier state.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
field(
|
||||
name = "meta",
|
||||
doc = "Meta modifier state.",
|
||||
type = type("lyng.Bool")
|
||||
)
|
||||
}
|
||||
|
||||
valDoc(
|
||||
name = "Console",
|
||||
doc = "Console runtime API.",
|
||||
type = type("Console")
|
||||
)
|
||||
valDoc(name = "ConsoleGeometry", doc = "Terminal geometry class.", type = type("lyng.Class"))
|
||||
valDoc(name = "ConsoleDetails", doc = "Console details class.", type = type("lyng.Class"))
|
||||
valDoc(name = "ConsoleEvent", doc = "Base console event class.", type = type("lyng.Class"))
|
||||
valDoc(name = "ConsoleResizeEvent", doc = "Resize event class.", type = type("lyng.Class"))
|
||||
valDoc(name = "ConsoleKeyEvent", doc = "Keyboard event class.", type = type("lyng.Class"))
|
||||
valDoc(name = "ConsoleEventStream", doc = "Iterable console event stream class.", type = type("lyng.Class"))
|
||||
}
|
||||
registered = true
|
||||
// No Kotlin-side doc registration: console.lyng is the source of truth.
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.HttpClient
|
||||
import io.ktor.client.call.body
|
||||
import io.ktor.client.engine.HttpClientEngineConfig
|
||||
import io.ktor.client.engine.HttpClientEngineFactory
|
||||
import io.ktor.client.plugins.timeout
|
||||
import io.ktor.client.request.HttpRequestBuilder
|
||||
import io.ktor.client.request.request
|
||||
import io.ktor.client.request.setBody
|
||||
import io.ktor.http.HttpMethod
|
||||
import io.ktor.http.headers
|
||||
import io.ktor.http.takeFrom
|
||||
|
||||
internal fun createKtorHttpEngine(
|
||||
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
|
||||
): LyngHttpEngine = KtorLyngHttpEngine(engineFactory)
|
||||
|
||||
private class KtorLyngHttpEngine(
|
||||
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
|
||||
) : LyngHttpEngine {
|
||||
private val clientResult = runCatching {
|
||||
HttpClient(engineFactory) {
|
||||
expectSuccess = false
|
||||
}
|
||||
}
|
||||
|
||||
override val isSupported: Boolean
|
||||
get() = clientResult.isSuccess
|
||||
|
||||
override suspend fun request(request: LyngHttpRequest): LyngHttpResponse {
|
||||
val httpClient = clientResult.getOrElse {
|
||||
throw UnsupportedOperationException(it.message ?: "HTTP client is not supported")
|
||||
}
|
||||
|
||||
val response = httpClient.request {
|
||||
applyRequest(request)
|
||||
}
|
||||
return LyngHttpResponse(
|
||||
status = response.status.value,
|
||||
statusText = response.status.description,
|
||||
headers = response.headers.entries().associate { it.key to it.value.toList() },
|
||||
bodyBytes = response.body<ByteArray>(),
|
||||
)
|
||||
}
|
||||
|
||||
private fun HttpRequestBuilder.applyRequest(request: LyngHttpRequest) {
|
||||
method = HttpMethod.parse(request.method.uppercase())
|
||||
url.takeFrom(request.url)
|
||||
headers {
|
||||
request.headers.forEach { (name, value) -> append(name, value) }
|
||||
}
|
||||
request.timeoutMillis?.let { timeout { requestTimeoutMillis = it } }
|
||||
when {
|
||||
request.bodyBytes != null && request.bodyText != null ->
|
||||
throw IllegalArgumentException("Only one of bodyText or bodyBytes may be set")
|
||||
request.bodyBytes != null -> setBody(request.bodyBytes)
|
||||
request.bodyText != null -> setBody(request.bodyText)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
data class LyngHttpRequest(
|
||||
val method: String,
|
||||
val url: String,
|
||||
val headers: Map<String, String> = emptyMap(),
|
||||
val bodyText: String? = null,
|
||||
val bodyBytes: ByteArray? = null,
|
||||
val timeoutMillis: Long? = null,
|
||||
)
|
||||
|
||||
data class LyngHttpResponse(
|
||||
val status: Int,
|
||||
val statusText: String,
|
||||
val headers: Map<String, List<String>>,
|
||||
val bodyBytes: ByteArray,
|
||||
)
|
||||
|
||||
interface LyngHttpEngine {
|
||||
val isSupported: Boolean
|
||||
suspend fun request(request: LyngHttpRequest): LyngHttpResponse
|
||||
}
|
||||
|
||||
internal object UnsupportedHttpEngine : LyngHttpEngine {
|
||||
override val isSupported: Boolean = false
|
||||
|
||||
override suspend fun request(request: LyngHttpRequest): LyngHttpResponse {
|
||||
throw UnsupportedOperationException("HTTP client is not supported on this runtime")
|
||||
}
|
||||
}
|
||||
|
||||
expect fun getSystemHttpEngine(): LyngHttpEngine
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.http.security
|
||||
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
|
||||
sealed interface HttpAccessOp {
|
||||
data class Request(val method: String, val url: String) : HttpAccessOp
|
||||
}
|
||||
|
||||
class HttpAccessDeniedException(
|
||||
val op: HttpAccessOp,
|
||||
val reasonDetail: String? = null,
|
||||
) : IllegalStateException("HTTP access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
|
||||
|
||||
interface HttpAccessPolicy {
|
||||
suspend fun check(op: HttpAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
|
||||
|
||||
suspend fun require(op: HttpAccessOp, ctx: AccessContext = AccessContext()) {
|
||||
val res = check(op, ctx)
|
||||
if (!res.isAllowed()) throw HttpAccessDeniedException(op, res.reason)
|
||||
}
|
||||
}
|
||||
|
||||
object PermitAllHttpAccessPolicy : HttpAccessPolicy {
|
||||
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Allow)
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
enum class LyngIpVersion {
|
||||
IPV4,
|
||||
IPV6,
|
||||
}
|
||||
|
||||
data class LyngSocketAddress(
|
||||
val host: String,
|
||||
val port: Int,
|
||||
val ipVersion: LyngIpVersion,
|
||||
val resolved: Boolean,
|
||||
)
|
||||
|
||||
data class LyngDatagram(
|
||||
val data: ByteArray,
|
||||
val address: LyngSocketAddress,
|
||||
)
|
||||
|
||||
interface LyngTcpSocket {
|
||||
fun isOpen(): Boolean
|
||||
fun localAddress(): LyngSocketAddress
|
||||
fun remoteAddress(): LyngSocketAddress
|
||||
suspend fun read(maxBytes: Int): ByteArray?
|
||||
suspend fun readLine(): String?
|
||||
suspend fun write(data: ByteArray)
|
||||
suspend fun writeUtf8(text: String)
|
||||
suspend fun flush()
|
||||
fun close()
|
||||
}
|
||||
|
||||
interface LyngTcpServer {
|
||||
fun isOpen(): Boolean
|
||||
fun localAddress(): LyngSocketAddress
|
||||
suspend fun accept(): LyngTcpSocket
|
||||
fun close()
|
||||
}
|
||||
|
||||
interface LyngUdpSocket {
|
||||
fun isOpen(): Boolean
|
||||
fun localAddress(): LyngSocketAddress
|
||||
suspend fun receive(maxBytes: Int): LyngDatagram?
|
||||
suspend fun send(data: ByteArray, host: String, port: Int)
|
||||
fun close()
|
||||
}
|
||||
|
||||
interface LyngNetEngine {
|
||||
val isSupported: Boolean
|
||||
val isTcpAvailable: Boolean
|
||||
val isTcpServerAvailable: Boolean
|
||||
val isUdpAvailable: Boolean
|
||||
|
||||
suspend fun resolve(host: String, port: Int): List<LyngSocketAddress>
|
||||
suspend fun tcpConnect(host: String, port: Int, timeoutMillis: Long?, noDelay: Boolean): LyngTcpSocket
|
||||
suspend fun tcpListen(host: String?, port: Int, backlog: Int, reuseAddress: Boolean): LyngTcpServer
|
||||
suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket
|
||||
}
|
||||
|
||||
internal object UnsupportedLyngNetEngine : LyngNetEngine {
|
||||
override val isSupported: Boolean = false
|
||||
override val isTcpAvailable: Boolean = false
|
||||
override val isTcpServerAvailable: Boolean = false
|
||||
override val isUdpAvailable: Boolean = false
|
||||
|
||||
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
|
||||
throw UnsupportedOperationException("Raw networking is not supported on this runtime")
|
||||
}
|
||||
|
||||
override suspend fun tcpConnect(host: String, port: Int, timeoutMillis: Long?, noDelay: Boolean): LyngTcpSocket {
|
||||
throw UnsupportedOperationException("TCP client sockets are not supported on this runtime")
|
||||
}
|
||||
|
||||
override suspend fun tcpListen(host: String?, port: Int, backlog: Int, reuseAddress: Boolean): LyngTcpServer {
|
||||
throw UnsupportedOperationException("TCP server sockets are not supported on this runtime")
|
||||
}
|
||||
|
||||
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
|
||||
throw UnsupportedOperationException("UDP sockets are not supported on this runtime")
|
||||
}
|
||||
}
|
||||
|
||||
expect fun getSystemNetEngine(): LyngNetEngine
|
||||
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.net.security
|
||||
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
|
||||
sealed interface NetAccessOp {
|
||||
data class Resolve(val host: String, val port: Int) : NetAccessOp
|
||||
data class TcpConnect(val host: String, val port: Int) : NetAccessOp
|
||||
data class TcpListen(val host: String?, val port: Int, val backlog: Int) : NetAccessOp
|
||||
data class UdpBind(val host: String?, val port: Int) : NetAccessOp
|
||||
}
|
||||
|
||||
class NetAccessDeniedException(
|
||||
val op: NetAccessOp,
|
||||
val reasonDetail: String? = null,
|
||||
) : IllegalStateException("Network access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
|
||||
|
||||
interface NetAccessPolicy {
|
||||
suspend fun check(op: NetAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
|
||||
|
||||
suspend fun require(op: NetAccessOp, ctx: AccessContext = AccessContext()) {
|
||||
val res = check(op, ctx)
|
||||
if (!res.isAllowed()) throw NetAccessDeniedException(op, res.reason)
|
||||
}
|
||||
}
|
||||
|
||||
object PermitAllNetAccessPolicy : NetAccessPolicy {
|
||||
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Allow)
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.HttpClient
|
||||
import io.ktor.client.engine.HttpClientEngineConfig
|
||||
import io.ktor.client.engine.HttpClientEngineFactory
|
||||
import io.ktor.client.plugins.websocket.WebSockets
|
||||
import io.ktor.client.plugins.websocket.webSocketSession
|
||||
import io.ktor.client.request.header
|
||||
import io.ktor.client.request.url
|
||||
import io.ktor.websocket.CloseReason
|
||||
import io.ktor.websocket.DefaultWebSocketSession
|
||||
import io.ktor.websocket.Frame
|
||||
import io.ktor.websocket.close
|
||||
import io.ktor.websocket.readText
|
||||
import io.ktor.websocket.send
|
||||
import kotlinx.coroutines.channels.ClosedReceiveChannelException
|
||||
|
||||
internal fun createKtorWsEngine(
|
||||
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
|
||||
): LyngWsEngine = KtorLyngWsEngine(engineFactory)
|
||||
|
||||
private class KtorLyngWsEngine(
|
||||
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
|
||||
) : LyngWsEngine {
|
||||
private val clientResult = runCatching {
|
||||
HttpClient(engineFactory) {
|
||||
install(WebSockets)
|
||||
}
|
||||
}
|
||||
|
||||
override val isSupported: Boolean
|
||||
get() = clientResult.isSuccess
|
||||
|
||||
override suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession {
|
||||
val client = clientResult.getOrElse {
|
||||
throw UnsupportedOperationException(it.message ?: "WebSocket client is not supported")
|
||||
}
|
||||
val session = client.webSocketSession {
|
||||
url(url)
|
||||
headers.forEach { (name, value) -> header(name, value) }
|
||||
}
|
||||
return KtorLyngWsSession(url, session)
|
||||
}
|
||||
}
|
||||
|
||||
private class KtorLyngWsSession(
|
||||
private val targetUrl: String,
|
||||
private val session: DefaultWebSocketSession,
|
||||
) : LyngWsSession {
|
||||
private var closed = false
|
||||
|
||||
override fun isOpen(): Boolean = !closed
|
||||
|
||||
override fun url(): String = targetUrl
|
||||
|
||||
override suspend fun sendText(text: String) {
|
||||
ensureOpen()
|
||||
session.send(text)
|
||||
}
|
||||
|
||||
override suspend fun sendBytes(data: ByteArray) {
|
||||
ensureOpen()
|
||||
session.send(data)
|
||||
}
|
||||
|
||||
override suspend fun receive(): LyngWsMessage? {
|
||||
if (closed) return null
|
||||
val frame = try {
|
||||
session.incoming.receive()
|
||||
} catch (_: ClosedReceiveChannelException) {
|
||||
closed = true
|
||||
return null
|
||||
}
|
||||
return when (frame) {
|
||||
is Frame.Text -> LyngWsMessage(isText = true, text = frame.readText())
|
||||
is Frame.Binary -> LyngWsMessage(isText = false, data = frame.data.copyOf())
|
||||
is Frame.Close -> {
|
||||
closed = true
|
||||
null
|
||||
}
|
||||
else -> receive()
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun close(code: Int, reason: String) {
|
||||
if (closed) return
|
||||
closed = true
|
||||
session.close(CloseReason(code.toShort(), reason))
|
||||
}
|
||||
|
||||
private fun ensureOpen() {
|
||||
if (closed) throw IllegalStateException("websocket session is closed")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
data class LyngWsMessage(
|
||||
val isText: Boolean,
|
||||
val text: String? = null,
|
||||
val data: ByteArray? = null,
|
||||
)
|
||||
|
||||
interface LyngWsSession {
|
||||
fun isOpen(): Boolean
|
||||
fun url(): String
|
||||
suspend fun sendText(text: String)
|
||||
suspend fun sendBytes(data: ByteArray)
|
||||
suspend fun receive(): LyngWsMessage?
|
||||
suspend fun close(code: Int, reason: String)
|
||||
}
|
||||
|
||||
interface LyngWsEngine {
|
||||
val isSupported: Boolean
|
||||
suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession
|
||||
}
|
||||
|
||||
internal object UnsupportedLyngWsEngine : LyngWsEngine {
|
||||
override val isSupported: Boolean = false
|
||||
|
||||
override suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession {
|
||||
throw UnsupportedOperationException("WebSocket client is not supported on this runtime")
|
||||
}
|
||||
}
|
||||
|
||||
expect fun getSystemWsEngine(): LyngWsEngine
|
||||
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.ws.security
|
||||
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
|
||||
sealed interface WsAccessOp {
|
||||
data class Connect(val url: String) : WsAccessOp
|
||||
data class Send(val url: String, val bytes: Int, val isText: Boolean) : WsAccessOp
|
||||
data class Receive(val url: String) : WsAccessOp
|
||||
}
|
||||
|
||||
class WsAccessDeniedException(
|
||||
val op: WsAccessOp,
|
||||
val reasonDetail: String? = null,
|
||||
) : IllegalStateException("WebSocket access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
|
||||
|
||||
interface WsAccessPolicy {
|
||||
suspend fun check(op: WsAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
|
||||
|
||||
suspend fun require(op: WsAccessOp, ctx: AccessContext = AccessContext()) {
|
||||
val res = check(op, ctx)
|
||||
if (!res.isAllowed()) throw WsAccessDeniedException(op, res.reason)
|
||||
}
|
||||
}
|
||||
|
||||
object PermitAllWsAccessPolicy : WsAccessPolicy {
|
||||
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Allow)
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.net
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyngio.net.getSystemNetEngine
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class LyngNetTcpServerExampleTest {
|
||||
|
||||
@Test
|
||||
fun tcpServerExampleRoundTripsOverLoopback() = runBlocking {
|
||||
val engine = getSystemNetEngine()
|
||||
if (!engine.isSupported || !engine.isTcpAvailable || !engine.isTcpServerAvailable) return@runBlocking
|
||||
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.tcpListen(0, "127.0.0.1")
|
||||
val port = server.localAddress().port
|
||||
val accepted = launch {
|
||||
val client = server.accept()
|
||||
val line = (client.read(4) as Buffer).decodeUtf8()
|
||||
client.writeUtf8("echo:" + line)
|
||||
client.flush()
|
||||
client.close()
|
||||
server.close()
|
||||
line
|
||||
}
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", port)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
socket.close()
|
||||
"${'$'}{accepted.await()}: ${'$'}reply"
|
||||
""".trimIndent()
|
||||
|
||||
val result = withTimeout(5_000) {
|
||||
Compiler.compile(code).execute(scope).inspect(scope)
|
||||
}
|
||||
|
||||
assertEquals("\"ping: echo:ping\"", result)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.darwin.Darwin
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Darwin)
|
||||
@@ -0,0 +1,8 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = createNativeKtorNetEngine(
|
||||
isSupported = true,
|
||||
isTcpAvailable = true,
|
||||
isTcpServerAvailable = true,
|
||||
isUdpAvailable = true,
|
||||
)
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.darwin.Darwin
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Darwin)
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.js.Js
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Js)
|
||||
@@ -0,0 +1,422 @@
|
||||
@file:Suppress("UnsafeCastFromDynamic", "SpellCheckingInspection")
|
||||
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
import kotlinx.coroutines.suspendCancellableCoroutine
|
||||
import kotlin.coroutines.resume
|
||||
import kotlin.coroutines.resumeWithException
|
||||
import kotlin.js.json
|
||||
import org.khronos.webgl.Uint8Array
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = jsNodeNetEngineOrNull ?: UnsupportedLyngNetEngine
|
||||
|
||||
private val jsNodeNetEngineOrNull: LyngNetEngine? by lazy {
|
||||
if (!isNodeRuntime()) return@lazy null
|
||||
val net = requireNodeModule("net") ?: return@lazy null
|
||||
val dgram = requireNodeModule("dgram") ?: return@lazy null
|
||||
val dns = requireNodeModule("dns") ?: return@lazy null
|
||||
JsNodeNetEngine(net, dgram, dns)
|
||||
}
|
||||
|
||||
private class JsNodeNetEngine(
|
||||
private val netModule: dynamic,
|
||||
private val dgramModule: dynamic,
|
||||
private val dnsModule: dynamic,
|
||||
) : LyngNetEngine {
|
||||
override val isSupported: Boolean = true
|
||||
override val isTcpAvailable: Boolean = true
|
||||
override val isTcpServerAvailable: Boolean = true
|
||||
override val isUdpAvailable: Boolean = true
|
||||
|
||||
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
|
||||
val family = netModule.isIP(host) as Int
|
||||
if (family == 4 || family == 6) {
|
||||
return listOf(
|
||||
LyngSocketAddress(
|
||||
host = host,
|
||||
port = port,
|
||||
ipVersion = if (family == 6) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = true,
|
||||
)
|
||||
)
|
||||
}
|
||||
return suspendCancellableCoroutine { cont ->
|
||||
dnsModule.lookup(host, json("all" to true), { error: dynamic, result: dynamic ->
|
||||
if (!cont.isActive) return@lookup
|
||||
if (error != null) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "DNS lookup failed"))
|
||||
return@lookup
|
||||
}
|
||||
val addresses = mutableListOf<LyngSocketAddress>()
|
||||
val items = result.unsafeCast<Array<dynamic>>()
|
||||
for (item in items) {
|
||||
val address = item.address?.unsafeCast<String>() ?: continue
|
||||
val itemFamily = item.family?.unsafeCast<Int>() ?: if (address.contains(':')) 6 else 4
|
||||
addresses += LyngSocketAddress(
|
||||
host = address,
|
||||
port = port,
|
||||
ipVersion = if (itemFamily == 6) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = true,
|
||||
)
|
||||
}
|
||||
cont.resume(addresses)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun tcpConnect(
|
||||
host: String,
|
||||
port: Int,
|
||||
timeoutMillis: Long?,
|
||||
noDelay: Boolean,
|
||||
): LyngTcpSocket {
|
||||
var socket: dynamic = null
|
||||
return try {
|
||||
val connected = suspend {
|
||||
suspendCancellableCoroutine<dynamic> { cont ->
|
||||
socket = netModule.createConnection(json("host" to host, "port" to port)) {
|
||||
if (cont.isActive) cont.resume(socket)
|
||||
}
|
||||
socket.once("error", { error: dynamic ->
|
||||
if (cont.isActive) {
|
||||
cont.resumeWithException(
|
||||
IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP connect failed")
|
||||
)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
val connectedSocket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connected() } else connected()
|
||||
connectedSocket.setNoDelay(noDelay)
|
||||
JsNodeTcpSocket(connectedSocket)
|
||||
} catch (e: Throwable) {
|
||||
if (socket != null) socket.destroy()
|
||||
throw e
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun tcpListen(
|
||||
host: String?,
|
||||
port: Int,
|
||||
backlog: Int,
|
||||
reuseAddress: Boolean,
|
||||
): LyngTcpServer {
|
||||
val accepted = Channel<LyngTcpSocket>(Channel.UNLIMITED)
|
||||
val server = netModule.createServer({ socket: dynamic ->
|
||||
accepted.trySend(JsNodeTcpSocket(socket))
|
||||
})
|
||||
server.on("error", { _: dynamic -> })
|
||||
val listenHost = host ?: "0.0.0.0"
|
||||
val options = json(
|
||||
"host" to listenHost,
|
||||
"port" to port,
|
||||
"backlog" to backlog,
|
||||
"exclusive" to !reuseAddress,
|
||||
)
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
server.once("error", { error: dynamic ->
|
||||
if (cont.isActive) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP listen failed"))
|
||||
}
|
||||
})
|
||||
server.listen(options) {
|
||||
if (cont.isActive) cont.resume(Unit)
|
||||
}
|
||||
}
|
||||
return JsNodeTcpServer(server, accepted)
|
||||
}
|
||||
|
||||
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
|
||||
val socketType = if ((host ?: "").contains(':')) "udp6" else "udp4"
|
||||
val socket = dgramModule.createSocket(json("type" to socketType, "reuseAddr" to reuseAddress))
|
||||
val incoming = Channel<LyngDatagram>(Channel.UNLIMITED)
|
||||
socket.on("message", { msg: dynamic, rinfo: dynamic ->
|
||||
incoming.trySend(
|
||||
LyngDatagram(
|
||||
data = dynamicToByteArray(msg),
|
||||
address = rinfoToAddress(rinfo),
|
||||
)
|
||||
)
|
||||
})
|
||||
socket.on("error", { _: dynamic -> })
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
socket.once("error", { error: dynamic ->
|
||||
if (cont.isActive) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "UDP bind failed"))
|
||||
}
|
||||
})
|
||||
socket.bind(port, host ?: "0.0.0.0") {
|
||||
if (cont.isActive) cont.resume(Unit)
|
||||
}
|
||||
}
|
||||
return JsNodeUdpSocket(socket, incoming)
|
||||
}
|
||||
}
|
||||
|
||||
private class JsNodeTcpSocket(
|
||||
private val socket: dynamic,
|
||||
) : LyngTcpSocket {
|
||||
private val incoming = Channel<ByteArray?>(Channel.UNLIMITED)
|
||||
private val buffered = ArrayDeque<Byte>()
|
||||
private var closed = false
|
||||
private var failure: Throwable? = null
|
||||
|
||||
init {
|
||||
socket.on("data", { chunk: dynamic ->
|
||||
incoming.trySend(dynamicToByteArray(chunk))
|
||||
})
|
||||
socket.on("end", {
|
||||
closed = true
|
||||
incoming.trySend(null)
|
||||
})
|
||||
socket.on("close", {
|
||||
closed = true
|
||||
incoming.trySend(null)
|
||||
})
|
||||
socket.on("error", { error: dynamic ->
|
||||
failure = IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP socket failed")
|
||||
closed = true
|
||||
incoming.trySend(null)
|
||||
})
|
||||
}
|
||||
|
||||
override fun isOpen(): Boolean = !closed && socket.destroyed != true
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socketAddress(
|
||||
host = socket.localAddress?.unsafeCast<String>() ?: "0.0.0.0",
|
||||
port = socket.localPort?.unsafeCast<Int>() ?: 0,
|
||||
family = socket.localFamily,
|
||||
resolved = true,
|
||||
)
|
||||
|
||||
override fun remoteAddress(): LyngSocketAddress = socketAddress(
|
||||
host = socket.remoteAddress?.unsafeCast<String>() ?: "0.0.0.0",
|
||||
port = socket.remotePort?.unsafeCast<Int>() ?: 0,
|
||||
family = socket.remoteFamily,
|
||||
resolved = true,
|
||||
)
|
||||
|
||||
override suspend fun read(maxBytes: Int): ByteArray? {
|
||||
if (!ensureBuffered()) return null
|
||||
val count = minOf(maxBytes, buffered.size)
|
||||
return ByteArray(count) { buffered.removeFirst() }
|
||||
}
|
||||
|
||||
override suspend fun readLine(): String? {
|
||||
while (true) {
|
||||
val newlineIndex = buffered.indexOfFirst { it == '\n'.code.toByte() }
|
||||
if (newlineIndex >= 0) {
|
||||
val raw = takeBuffered(newlineIndex + 1)
|
||||
val trimmed = if (raw.lastOrNull() == '\n'.code.toByte()) raw.dropLast(1) else raw
|
||||
val withoutCr = if (trimmed.lastOrNull() == '\r'.code.toByte()) trimmed.dropLast(1) else trimmed
|
||||
return withoutCr.toByteArray().decodeToString()
|
||||
}
|
||||
if (!fillBuffer()) break
|
||||
}
|
||||
if (buffered.isEmpty()) {
|
||||
failure?.let { throw it }
|
||||
return null
|
||||
}
|
||||
return takeBuffered(buffered.size).toByteArray().decodeToString()
|
||||
}
|
||||
|
||||
override suspend fun write(data: ByteArray) {
|
||||
ensureOpen()
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
socket.write(byteArrayToUint8Array(data), { error: dynamic ->
|
||||
if (!cont.isActive) return@write
|
||||
if (error != null) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP write failed"))
|
||||
} else {
|
||||
cont.resume(Unit)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun writeUtf8(text: String) {
|
||||
ensureOpen()
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
socket.write(text, "utf8", { error: dynamic ->
|
||||
if (!cont.isActive) return@write
|
||||
if (error != null) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP write failed"))
|
||||
} else {
|
||||
cont.resume(Unit)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
ensureOpen()
|
||||
if (socket.writableNeedDrain == true) {
|
||||
withTimeoutOrNull(5_000) {
|
||||
awaitNodeEvent(socket, "drain")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
if (socket.destroyed == true) {
|
||||
incoming.trySend(null)
|
||||
return
|
||||
}
|
||||
if (socket.writable == true) socket.end() else socket.destroy()
|
||||
}
|
||||
|
||||
private suspend fun ensureBuffered(): Boolean {
|
||||
if (buffered.isNotEmpty()) return true
|
||||
return fillBuffer()
|
||||
}
|
||||
|
||||
private suspend fun fillBuffer(): Boolean {
|
||||
while (buffered.isEmpty()) {
|
||||
val chunk = incoming.receive()
|
||||
if (chunk == null) {
|
||||
failure?.let { if (buffered.isEmpty()) throw it }
|
||||
return buffered.isNotEmpty()
|
||||
}
|
||||
chunk.forEach { buffered.addLast(it) }
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
private fun takeBuffered(count: Int): List<Byte> = List(count) { buffered.removeFirst() }
|
||||
|
||||
private fun ensureOpen() {
|
||||
if (!isOpen()) throw IllegalStateException("tcp socket is closed")
|
||||
}
|
||||
}
|
||||
|
||||
private class JsNodeTcpServer(
|
||||
private val server: dynamic,
|
||||
private val accepted: Channel<LyngTcpSocket>,
|
||||
) : LyngTcpServer {
|
||||
private var closed = false
|
||||
|
||||
override fun isOpen(): Boolean = !closed && server.listening == true
|
||||
|
||||
override fun localAddress(): LyngSocketAddress {
|
||||
val info = server.address()
|
||||
return socketAddress(
|
||||
host = info.address?.unsafeCast<String>() ?: "0.0.0.0",
|
||||
port = info.port?.unsafeCast<Int>() ?: 0,
|
||||
family = info.family,
|
||||
resolved = true,
|
||||
)
|
||||
}
|
||||
|
||||
override suspend fun accept(): LyngTcpSocket = accepted.receive()
|
||||
|
||||
override fun close() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
server.close()
|
||||
accepted.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class JsNodeUdpSocket(
|
||||
private val socket: dynamic,
|
||||
private val incoming: Channel<LyngDatagram>,
|
||||
) : LyngUdpSocket {
|
||||
private var closed = false
|
||||
|
||||
override fun isOpen(): Boolean = !closed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = rinfoToAddress(socket.address())
|
||||
|
||||
override suspend fun receive(maxBytes: Int): LyngDatagram? {
|
||||
val datagram = incoming.receiveCatching().getOrNull() ?: return null
|
||||
return if (datagram.data.size <= maxBytes) datagram else datagram.copy(data = datagram.data.copyOf(maxBytes))
|
||||
}
|
||||
|
||||
override suspend fun send(data: ByteArray, host: String, port: Int) {
|
||||
if (closed) throw IllegalStateException("udp socket is closed")
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
socket.send(byteArrayToUint8Array(data), port, host, { error: dynamic ->
|
||||
if (!cont.isActive) return@send
|
||||
if (error != null) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "UDP send failed"))
|
||||
} else {
|
||||
cont.resume(Unit)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
socket.close()
|
||||
incoming.close()
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun awaitNodeEvent(target: dynamic, name: String) {
|
||||
suspendCancellableCoroutine<Unit> { cont ->
|
||||
target.once("error", { error: dynamic ->
|
||||
if (cont.isActive) {
|
||||
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "Node operation failed"))
|
||||
}
|
||||
})
|
||||
target.once(name) {
|
||||
if (cont.isActive) cont.resume(Unit)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun socketAddress(host: String, port: Int, family: dynamic, resolved: Boolean): LyngSocketAddress =
|
||||
LyngSocketAddress(
|
||||
host = host,
|
||||
port = port,
|
||||
ipVersion = when (family?.toString()) {
|
||||
"IPv6", "6" -> LyngIpVersion.IPV6
|
||||
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
|
||||
},
|
||||
resolved = resolved,
|
||||
)
|
||||
|
||||
private fun rinfoToAddress(rinfo: dynamic): LyngSocketAddress = socketAddress(
|
||||
host = rinfo.address?.unsafeCast<String>() ?: "0.0.0.0",
|
||||
port = rinfo.port?.unsafeCast<Int>() ?: 0,
|
||||
family = rinfo.family,
|
||||
resolved = true,
|
||||
)
|
||||
|
||||
private fun isNodeRuntime(): Boolean = js(
|
||||
"""
|
||||
typeof process !== "undefined" &&
|
||||
process != null &&
|
||||
process.versions != null &&
|
||||
process.versions.node != null
|
||||
"""
|
||||
).unsafeCast<Boolean>()
|
||||
|
||||
private fun requireNodeModule(name: String): dynamic {
|
||||
val requireFn = js("typeof require !== 'undefined' ? require : undefined")
|
||||
if (requireFn == js("undefined")) return null
|
||||
return try {
|
||||
requireFn(name)
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
private fun dynamicToByteArray(value: dynamic): ByteArray {
|
||||
val source = js("new Uint8Array(value)").unsafeCast<Uint8Array>()
|
||||
val size = source.length
|
||||
return ByteArray(size) { index -> source.asDynamic()[index].unsafeCast<Byte>() }
|
||||
}
|
||||
|
||||
private fun byteArrayToUint8Array(value: ByteArray): Uint8Array {
|
||||
val out = Uint8Array(value.size)
|
||||
value.forEachIndexed { index, byte -> out.asDynamic()[index] = byte.toInt() and 0xff }
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.js.Js
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Js)
|
||||
@@ -0,0 +1,117 @@
|
||||
package net.sergeych.lyng.io.net
|
||||
|
||||
import kotlinx.coroutines.DelicateCoroutinesApi
|
||||
import kotlinx.coroutines.GlobalScope
|
||||
import kotlinx.coroutines.async
|
||||
import kotlinx.coroutines.promise
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.net.getSystemNetEngine
|
||||
import net.sergeych.lyngio.net.security.NetAccessOp
|
||||
import net.sergeych.lyngio.net.security.NetAccessPolicy
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertFailsWith
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
@OptIn(DelicateCoroutinesApi::class)
|
||||
class LyngNetModuleJsNodeTest {
|
||||
@Test
|
||||
fun testResolveAndCapabilities() = GlobalScope.promise {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.net
|
||||
|
||||
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
|
||||
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("true,true,true,true"), result)
|
||||
assertTrue(result.contains("127.0.0.1:4040"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testTcpConnectConvenience() = GlobalScope.promise {
|
||||
val engine = getSystemNetEngine()
|
||||
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 8, reuseAddress = true)
|
||||
val serverPort = server.localAddress().port
|
||||
val worker = async {
|
||||
val client = server.accept()
|
||||
val line = client.read(4)?.decodeToString()
|
||||
client.writeUtf8("reply:$line")
|
||||
client.flush()
|
||||
client.close()
|
||||
}
|
||||
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", $serverPort)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
val localPort = socket.localAddress().port
|
||||
val remotePort = socket.remoteAddress().port
|
||||
socket.close()
|
||||
[reply, localPort > 0, remotePort == $serverPort]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
worker.await()
|
||||
server.close()
|
||||
assertTrue(result.contains("reply:ping"), result)
|
||||
assertTrue(result.contains("true,true"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testUdpLoopback() = GlobalScope.promise {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.udpBind(0, "127.0.0.1")
|
||||
val client = Net.udpBind(0, "127.0.0.1")
|
||||
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
|
||||
val d = server.receive()
|
||||
client.close()
|
||||
server.close()
|
||||
[d.data.decodeUtf8(), d.address.port > 0]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("[ping,true]"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPolicyDenialSurfacesAsLyngError() = GlobalScope.promise {
|
||||
val scope = Script.newScope()
|
||||
val denyAll = object : NetAccessPolicy {
|
||||
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Deny, "blocked by test policy")
|
||||
}
|
||||
createNetModule(denyAll, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.net
|
||||
Net.tcpConnect("127.0.0.1", 1)
|
||||
""".trimIndent()
|
||||
|
||||
val error = assertFailsWith<ExecutionError> {
|
||||
Compiler.compile(code).execute(scope)
|
||||
}
|
||||
assertTrue(error.errorMessage.isNotBlank())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package net.sergeych.lyngio
|
||||
|
||||
import kotlinx.coroutines.DelicateCoroutinesApi
|
||||
import kotlinx.coroutines.GlobalScope
|
||||
import kotlinx.coroutines.async
|
||||
import kotlinx.coroutines.promise
|
||||
import net.sergeych.lyngio.net.LyngIpVersion
|
||||
import net.sergeych.lyngio.net.getSystemNetEngine
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
@OptIn(DelicateCoroutinesApi::class)
|
||||
class NetJsNodeTest {
|
||||
@Test
|
||||
fun testNodeNetCapabilitiesAndResolve() = GlobalScope.promise {
|
||||
val engine = getSystemNetEngine()
|
||||
assertTrue(engine.isSupported)
|
||||
assertTrue(engine.isTcpAvailable)
|
||||
assertTrue(engine.isTcpServerAvailable)
|
||||
assertTrue(engine.isUdpAvailable)
|
||||
|
||||
val resolved = engine.resolve("127.0.0.1", 4040)
|
||||
assertTrue(resolved.isNotEmpty())
|
||||
assertEquals(4040, resolved.first().port)
|
||||
assertEquals(LyngIpVersion.IPV4, resolved.first().ipVersion)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testNodeTcpLoopback() = GlobalScope.promise {
|
||||
val engine = getSystemNetEngine()
|
||||
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 8, reuseAddress = true)
|
||||
val accepted = async {
|
||||
val socket = server.accept()
|
||||
val line = socket.readLine()
|
||||
socket.writeUtf8("echo:$line\n")
|
||||
socket.flush()
|
||||
socket.close()
|
||||
line
|
||||
}
|
||||
|
||||
val client = engine.tcpConnect("127.0.0.1", server.localAddress().port, timeoutMillis = null, noDelay = true)
|
||||
client.writeUtf8("ping\n")
|
||||
client.flush()
|
||||
val reply = client.readLine()
|
||||
client.close()
|
||||
server.close()
|
||||
|
||||
assertEquals("ping", accepted.await())
|
||||
assertEquals("echo:ping", reply)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testNodeUdpLoopback() = GlobalScope.promise {
|
||||
val engine = getSystemNetEngine()
|
||||
val server = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
|
||||
val client = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
|
||||
|
||||
client.send("ping".encodeToByteArray(), "127.0.0.1", server.localAddress().port)
|
||||
val received = server.receive(1024)
|
||||
|
||||
client.close()
|
||||
server.close()
|
||||
|
||||
assertNotNull(received)
|
||||
assertEquals("ping", received.data.decodeToString())
|
||||
assertTrue(received.address.port > 0)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package net.sergeych.lyngio
|
||||
|
||||
import net.sergeych.lyngio.http.getSystemHttpEngine
|
||||
import net.sergeych.lyngio.ws.getSystemWsEngine
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class PlatformCapabilityJsTest {
|
||||
@Test
|
||||
fun testJsHttpAndWsCapabilitiesReportSupported() {
|
||||
assertTrue(getSystemHttpEngine().isSupported, "JS HTTP engine should be available")
|
||||
assertTrue(getSystemWsEngine().isSupported, "JS websocket engine should be available")
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,7 @@ import org.jline.terminal.Terminal
|
||||
import org.jline.terminal.TerminalBuilder
|
||||
import org.jline.utils.NonBlockingReader
|
||||
import java.io.EOFException
|
||||
import java.io.InterruptedIOException
|
||||
import java.util.*
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
@@ -35,13 +36,104 @@ import kotlin.time.Duration.Companion.milliseconds
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
import kotlin.time.TimeSource
|
||||
|
||||
internal object JvmConsoleKeyDecoder {
|
||||
fun decode(firstCode: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
|
||||
if (firstCode == 27) {
|
||||
val next = nextCode(25L)
|
||||
if (next == null || next < 0) {
|
||||
return key("Escape")
|
||||
}
|
||||
if (next == '['.code || next == 'O'.code) {
|
||||
val sb = StringBuilder()
|
||||
sb.append(next.toChar())
|
||||
var i = 0
|
||||
while (i < 6) {
|
||||
val c = nextCode(25L) ?: break
|
||||
if (c < 0) break
|
||||
sb.append(c.toChar())
|
||||
if (c.toChar().isLetter() || c == '~'.code) break
|
||||
i += 1
|
||||
}
|
||||
return keyFromAnsiSequence(sb.toString()) ?: key("Escape")
|
||||
}
|
||||
val base = decodePlainKey(next)
|
||||
return ConsoleEvent.KeyDown(
|
||||
key = base.key,
|
||||
code = base.code,
|
||||
ctrl = base.ctrl,
|
||||
alt = true,
|
||||
shift = base.shift,
|
||||
meta = false,
|
||||
)
|
||||
}
|
||||
return decodePlainKey(firstCode)
|
||||
}
|
||||
|
||||
private fun decodePlainKey(code: Int): ConsoleEvent.KeyDown = when (code) {
|
||||
3 -> key("c", ctrl = true)
|
||||
9 -> key("Tab")
|
||||
10, 13 -> key("Enter")
|
||||
127, 8 -> key("Backspace")
|
||||
32 -> key(" ")
|
||||
else -> {
|
||||
if (code in 1..26) {
|
||||
val ch = ('a'.code + code - 1).toChar().toString()
|
||||
key(ch, ctrl = true)
|
||||
} else {
|
||||
val ch = code.toChar().toString()
|
||||
key(ch, shift = ch.length == 1 && ch[0].isLetter() && ch[0].isUpperCase())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun keyFromAnsiSequence(seq: String): ConsoleEvent.KeyDown? {
|
||||
val shift = seq.contains(";2")
|
||||
val alt = seq.contains(";3")
|
||||
val ctrl = seq.contains(";5")
|
||||
val key = when {
|
||||
seq.endsWith("A") -> "ArrowUp"
|
||||
seq.endsWith("B") -> "ArrowDown"
|
||||
seq.endsWith("C") -> "ArrowRight"
|
||||
seq.endsWith("D") -> "ArrowLeft"
|
||||
seq.endsWith("H") -> "Home"
|
||||
seq.endsWith("F") -> "End"
|
||||
seq.endsWith("~") -> when (seq.substringAfter('[').substringBefore(';').substringBefore('~')) {
|
||||
"2" -> "Insert"
|
||||
"3" -> "Delete"
|
||||
"5" -> "PageUp"
|
||||
"6" -> "PageDown"
|
||||
else -> null
|
||||
}
|
||||
else -> null
|
||||
} ?: return null
|
||||
return key(key, ctrl = ctrl, alt = alt, shift = shift)
|
||||
}
|
||||
|
||||
private fun key(
|
||||
value: String,
|
||||
ctrl: Boolean = false,
|
||||
alt: Boolean = false,
|
||||
shift: Boolean = false,
|
||||
): ConsoleEvent.KeyDown {
|
||||
require(value.isNotEmpty()) { "ConsoleEvent.KeyDown.key must never be empty" }
|
||||
return ConsoleEvent.KeyDown(
|
||||
key = value,
|
||||
code = null,
|
||||
ctrl = ctrl,
|
||||
alt = alt,
|
||||
shift = shift,
|
||||
meta = false,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* JVM console implementation:
|
||||
* - output/capabilities/input use a single JLine terminal instance
|
||||
* to avoid dual-terminal contention.
|
||||
*/
|
||||
object JvmLyngConsole : LyngConsole {
|
||||
private const val DEBUG_REVISION = "jline-r26-force-rebuild-on-noop-recovery-2026-03-19"
|
||||
private const val DEBUG_REVISION = "jline-r27-no-close-on-vm-iterator-cancel-2026-03-19"
|
||||
private val codeSourceLocation: String by lazy {
|
||||
runCatching {
|
||||
JvmLyngConsole::class.java.protectionDomain?.codeSource?.location?.toString()
|
||||
@@ -50,6 +142,44 @@ object JvmLyngConsole : LyngConsole {
|
||||
|
||||
private val terminalRef = AtomicReference<Terminal?>(null)
|
||||
private val terminalInitLock = Any()
|
||||
private val shutdownHook = Thread(
|
||||
{
|
||||
restoreTerminalStateOnShutdown()
|
||||
},
|
||||
"lyng-console-shutdown"
|
||||
).apply { isDaemon = true }
|
||||
|
||||
init {
|
||||
runCatching { Runtime.getRuntime().addShutdownHook(shutdownHook) }
|
||||
.onFailure { consoleFlowDebug("jline-events: shutdown hook install failed", it) }
|
||||
}
|
||||
|
||||
private fun restoreTerminalStateOnShutdown() {
|
||||
val term = terminalRef.get() ?: return
|
||||
runCatching {
|
||||
term.writer().print("\u001B[?25h")
|
||||
term.writer().print("\u001B[?1049l")
|
||||
term.writer().flush()
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: shutdown visual restore failed", it)
|
||||
}
|
||||
val saved = if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
|
||||
try {
|
||||
rawModeRequested = false
|
||||
val s = rawSavedAttributes
|
||||
rawSavedAttributes = null
|
||||
s
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
} else {
|
||||
null
|
||||
}
|
||||
if (saved != null) {
|
||||
runCatching { term.setAttributes(saved) }
|
||||
.onFailure { consoleFlowDebug("jline-events: shutdown raw attrs restore failed", it) }
|
||||
}
|
||||
}
|
||||
|
||||
private fun currentTerminal(): Terminal? {
|
||||
val existing = terminalRef.get()
|
||||
@@ -176,10 +306,29 @@ object JvmLyngConsole : LyngConsole {
|
||||
var reader = activeTerm.reader()
|
||||
var keyThread: Thread? = null
|
||||
var heartbeatThread: Thread? = null
|
||||
val resizeEmitMutex = Any()
|
||||
var lastResizeCols = Int.MIN_VALUE
|
||||
var lastResizeRows = Int.MIN_VALUE
|
||||
|
||||
fun emitResize() {
|
||||
val size = runCatching { activeTerm.size }.getOrNull() ?: return
|
||||
out.trySend(ConsoleEvent.Resize(size.columns, size.rows))
|
||||
val cols = size.columns
|
||||
val rows = size.rows
|
||||
if (cols < 1 || rows < 1) {
|
||||
consoleFlowDebug("jline-events: ignored invalid resize columns=$cols rows=$rows")
|
||||
return
|
||||
}
|
||||
val shouldEmit = synchronized(resizeEmitMutex) {
|
||||
if (cols == lastResizeCols && rows == lastResizeRows) {
|
||||
false
|
||||
} else {
|
||||
lastResizeCols = cols
|
||||
lastResizeRows = rows
|
||||
true
|
||||
}
|
||||
}
|
||||
if (!shouldEmit) return
|
||||
out.trySend(ConsoleEvent.Resize(cols, rows))
|
||||
}
|
||||
|
||||
fun cleanup() {
|
||||
@@ -270,13 +419,13 @@ object JvmLyngConsole : LyngConsole {
|
||||
.onFailure { consoleFlowDebug("jline-events: reader shutdown failed during recovery", it) }
|
||||
|
||||
reader = activeTerm.reader()
|
||||
if (reader.hashCode() == prevReader.hashCode()) {
|
||||
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()} -> forcing terminal rebuild")
|
||||
if (reader === prevReader) {
|
||||
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)} -> forcing terminal rebuild")
|
||||
if (!tryRebuildTerminal()) {
|
||||
consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader")
|
||||
}
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: reader recovered oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()}")
|
||||
consoleFlowDebug("jline-events: reader recovered oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)}")
|
||||
}
|
||||
|
||||
readerRecoveries.incrementAndGet()
|
||||
@@ -305,18 +454,56 @@ object JvmLyngConsole : LyngConsole {
|
||||
} else {
|
||||
keySendFailures.incrementAndGet()
|
||||
}
|
||||
} catch (_: InterruptedException) {
|
||||
break
|
||||
} catch (e: InterruptedException) {
|
||||
// Keep input alive if this is a transient interrupt while still running.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: key-reader interrupted; scheduling reader recovery", e)
|
||||
Thread.interrupted()
|
||||
continue
|
||||
} catch (e: InterruptedIOException) {
|
||||
// Common during reader shutdown/rebind. Recover silently and keep input flowing.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: read interrupted; scheduling reader recovery", e)
|
||||
try {
|
||||
Thread.sleep(10)
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during recovery backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
} catch (e: EOFException) {
|
||||
// EOF from reader should trigger rebind/rebuild rather than ending input stream.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: reader EOF; scheduling reader recovery", e)
|
||||
try {
|
||||
Thread.sleep(20)
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during EOF backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
readFailures.incrementAndGet()
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: blocking read failed", e)
|
||||
try {
|
||||
Thread.sleep(50)
|
||||
} catch (_: InterruptedException) {
|
||||
break
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during error backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
}
|
||||
}
|
||||
consoleFlowDebug(
|
||||
"jline-events: key-reader thread stopped running=${running.get()} keyLoopRunning=${keyLoopRunning.get()} loops=${keyLoopCount.get()} keys=${keyEvents.get()} readFailures=${readFailures.get()}"
|
||||
)
|
||||
}
|
||||
|
||||
heartbeatThread = thread(start = true, isDaemon = true, name = "lyng-jline-heartbeat") {
|
||||
@@ -334,11 +521,17 @@ object JvmLyngConsole : LyngConsole {
|
||||
val readBlockedMs = if (readStartNs > 0L && readEndNs < readStartNs) {
|
||||
(System.nanoTime() - readStartNs) / 1_000_000L
|
||||
} else 0L
|
||||
if (requested && keyCodesRead.get() > 0L && idleMs >= 1400L) {
|
||||
val streamIdle = requested && keyCodesRead.get() > 0L && idleMs >= 1400L
|
||||
val readStalled = requested && readBlockedMs >= 1600L
|
||||
if (streamIdle || readStalled) {
|
||||
val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L
|
||||
if (sinceRecoveryMs >= 1200L) {
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery")
|
||||
if (readStalled) {
|
||||
consoleFlowDebug("jline-events: key read blocked ${readBlockedMs}ms; scheduling reader recovery")
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery")
|
||||
}
|
||||
}
|
||||
}
|
||||
consoleFlowDebug(
|
||||
@@ -366,6 +559,7 @@ object JvmLyngConsole : LyngConsole {
|
||||
}
|
||||
|
||||
override suspend fun close() {
|
||||
consoleFlowDebug("jline-events: collector close requested", Throwable("collector close caller"))
|
||||
cleanup()
|
||||
consoleFlowDebug(
|
||||
"jline-events: collector ended keys=${keyEvents.get()} readFailures=${readFailures.get()}"
|
||||
@@ -405,40 +599,7 @@ object JvmLyngConsole : LyngConsole {
|
||||
val code = reader.read(120L)
|
||||
if (code == NonBlockingReader.READ_EXPIRED) return null
|
||||
if (code < 0) throw EOFException("non-blocking reader returned EOF")
|
||||
return decodeKey(code) { timeout -> readNextCode(reader, timeout) }
|
||||
}
|
||||
|
||||
private fun decodeKey(code: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
|
||||
if (code == 27) {
|
||||
val next = nextCode(25L)
|
||||
if (next == null || next < 0) {
|
||||
return key("Escape")
|
||||
}
|
||||
if (next == '['.code || next == 'O'.code) {
|
||||
val sb = StringBuilder()
|
||||
sb.append(next.toChar())
|
||||
var i = 0
|
||||
while (i < 6) {
|
||||
val c = nextCode(25L) ?: break
|
||||
if (c < 0) break
|
||||
sb.append(c.toChar())
|
||||
if (c.toChar().isLetter() || c == '~'.code) break
|
||||
i += 1
|
||||
}
|
||||
return keyFromAnsiSequence(sb.toString()) ?: key("Escape")
|
||||
}
|
||||
// Alt+key
|
||||
val base = decodePlainKey(next)
|
||||
return ConsoleEvent.KeyDown(
|
||||
key = base.key,
|
||||
code = base.code,
|
||||
ctrl = base.ctrl,
|
||||
alt = true,
|
||||
shift = base.shift,
|
||||
meta = false
|
||||
)
|
||||
}
|
||||
return decodePlainKey(code)
|
||||
return JvmConsoleKeyDecoder.decode(code) { timeout -> readNextCode(reader, timeout) }
|
||||
}
|
||||
|
||||
private fun readNextCode(reader: NonBlockingReader, timeoutMs: Long): Int? {
|
||||
@@ -447,50 +608,4 @@ object JvmLyngConsole : LyngConsole {
|
||||
if (c < 0) throw EOFException("non-blocking reader returned EOF while decoding key sequence")
|
||||
return c
|
||||
}
|
||||
|
||||
|
||||
private fun decodePlainKey(code: Int): ConsoleEvent.KeyDown = when (code) {
|
||||
3 -> key("c", ctrl = true)
|
||||
9 -> key("Tab")
|
||||
10, 13 -> key("Enter")
|
||||
127, 8 -> key("Backspace")
|
||||
32 -> key(" ")
|
||||
else -> {
|
||||
if (code in 1..26) {
|
||||
val ch = ('a'.code + code - 1).toChar().toString()
|
||||
key(ch, ctrl = true)
|
||||
} else {
|
||||
val ch = code.toChar().toString()
|
||||
key(ch, shift = ch.length == 1 && ch[0].isLetter() && ch[0].isUpperCase())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun keyFromAnsiSequence(seq: String): ConsoleEvent.KeyDown? = when (seq) {
|
||||
"[A", "OA" -> key("ArrowUp")
|
||||
"[B", "OB" -> key("ArrowDown")
|
||||
"[C", "OC" -> key("ArrowRight")
|
||||
"[D", "OD" -> key("ArrowLeft")
|
||||
"[H", "OH" -> key("Home")
|
||||
"[F", "OF" -> key("End")
|
||||
"[2~" -> key("Insert")
|
||||
"[3~" -> key("Delete")
|
||||
"[5~" -> key("PageUp")
|
||||
"[6~" -> key("PageDown")
|
||||
else -> null
|
||||
}
|
||||
|
||||
private fun key(
|
||||
value: String,
|
||||
ctrl: Boolean = false,
|
||||
alt: Boolean = false,
|
||||
shift: Boolean = false,
|
||||
): ConsoleEvent.KeyDown = ConsoleEvent.KeyDown(
|
||||
key = value,
|
||||
code = null,
|
||||
ctrl = ctrl,
|
||||
alt = alt,
|
||||
shift = shift,
|
||||
meta = false
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.cio.CIO
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(CIO)
|
||||
@@ -0,0 +1,223 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
import io.ktor.network.selector.ActorSelectorManager
|
||||
import io.ktor.network.selector.SelectorManager
|
||||
import io.ktor.network.sockets.BoundDatagramSocket
|
||||
import io.ktor.network.sockets.InetSocketAddress
|
||||
import io.ktor.network.sockets.ServerSocket
|
||||
import io.ktor.network.sockets.Socket
|
||||
import io.ktor.network.sockets.aSocket
|
||||
import io.ktor.network.sockets.isClosed
|
||||
import io.ktor.network.sockets.openReadChannel
|
||||
import io.ktor.network.sockets.openWriteChannel
|
||||
import io.ktor.network.sockets.toJavaAddress
|
||||
import io.ktor.utils.io.ByteReadChannel
|
||||
import io.ktor.utils.io.ByteWriteChannel
|
||||
import io.ktor.utils.io.readAvailable
|
||||
import io.ktor.utils.io.readUTF8Line
|
||||
import io.ktor.utils.io.writeFully
|
||||
import io.ktor.utils.io.writeStringUtf8
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import kotlinx.io.Buffer
|
||||
import kotlinx.io.readByteArray
|
||||
import java.net.Inet4Address
|
||||
import java.net.Inet6Address
|
||||
import java.net.InetAddress
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = JvmKtorNetEngine
|
||||
|
||||
private object JvmKtorNetEngine : LyngNetEngine {
|
||||
private val selectorManager: SelectorManager by lazy { ActorSelectorManager(Dispatchers.IO) }
|
||||
|
||||
override val isSupported: Boolean = true
|
||||
override val isTcpAvailable: Boolean = true
|
||||
override val isTcpServerAvailable: Boolean = true
|
||||
override val isUdpAvailable: Boolean = true
|
||||
|
||||
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> = withContext(Dispatchers.IO) {
|
||||
InetAddress.getAllByName(host).map { address ->
|
||||
address.toLyngSocketAddress(port = port, resolved = true)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun tcpConnect(
|
||||
host: String,
|
||||
port: Int,
|
||||
timeoutMillis: Long?,
|
||||
noDelay: Boolean,
|
||||
): LyngTcpSocket {
|
||||
val connectBlock: suspend () -> Socket = {
|
||||
aSocket(selectorManager).tcp().connect(host, port) {
|
||||
this.noDelay = noDelay
|
||||
}
|
||||
}
|
||||
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
|
||||
return JvmLyngTcpSocket(socket)
|
||||
}
|
||||
|
||||
override suspend fun tcpListen(
|
||||
host: String?,
|
||||
port: Int,
|
||||
backlog: Int,
|
||||
reuseAddress: Boolean,
|
||||
): LyngTcpServer {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
|
||||
backlogSize = backlog
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return JvmLyngTcpServer(server)
|
||||
}
|
||||
|
||||
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return JvmLyngUdpSocket(socket)
|
||||
}
|
||||
}
|
||||
|
||||
private class JvmLyngTcpSocket(
|
||||
private val socket: Socket,
|
||||
) : LyngTcpSocket {
|
||||
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
|
||||
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
|
||||
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun read(maxBytes: Int): ByteArray? {
|
||||
if (!input.awaitContent(1)) return null
|
||||
val buffer = ByteArray(maxBytes)
|
||||
val count = input.readAvailable(buffer, 0, maxBytes)
|
||||
return when {
|
||||
count <= 0 -> null
|
||||
count == maxBytes -> buffer
|
||||
else -> buffer.copyOf(count)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun readLine(): String? = input.readUTF8Line()
|
||||
|
||||
override suspend fun write(data: ByteArray) {
|
||||
output.writeFully(data, 0, data.size)
|
||||
}
|
||||
|
||||
override suspend fun writeUtf8(text: String) {
|
||||
output.writeStringUtf8(text)
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
output.flush()
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class JvmLyngTcpServer(
|
||||
private val server: ServerSocket,
|
||||
) : LyngTcpServer {
|
||||
override fun isOpen(): Boolean = !server.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun accept(): LyngTcpSocket = JvmLyngTcpSocket(server.accept())
|
||||
|
||||
override fun close() {
|
||||
server.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class JvmLyngUdpSocket(
|
||||
private val socket: BoundDatagramSocket,
|
||||
) : LyngUdpSocket {
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun receive(maxBytes: Int): LyngDatagram? {
|
||||
val datagram = try {
|
||||
socket.receive()
|
||||
} catch (e: Throwable) {
|
||||
if (!isOpen()) return null
|
||||
throw e
|
||||
}
|
||||
val bytes = datagram.packet.readByteArray().let {
|
||||
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
|
||||
}
|
||||
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
|
||||
}
|
||||
|
||||
override suspend fun send(data: ByteArray, host: String, port: Int) {
|
||||
val packet = Buffer()
|
||||
packet.write(data)
|
||||
socket.send(io.ktor.network.sockets.Datagram(packet, InetSocketAddress(host, port)))
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private fun io.ktor.network.sockets.SocketAddress.toLyngSocketAddress(
|
||||
port: Int? = null,
|
||||
resolved: Boolean,
|
||||
): LyngSocketAddress {
|
||||
val javaAddress = this.toJavaAddress()
|
||||
val inetSocket = javaAddress as? java.net.InetSocketAddress
|
||||
if (inetSocket != null) {
|
||||
val inetAddress = inetSocket.address
|
||||
val host = inetAddress?.hostAddress ?: inetSocket.hostString
|
||||
val actualPort = port ?: inetSocket.port
|
||||
val version = when (inetAddress) {
|
||||
is Inet6Address -> LyngIpVersion.IPV6
|
||||
is Inet4Address -> LyngIpVersion.IPV4
|
||||
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
|
||||
}
|
||||
return LyngSocketAddress(host = host, port = actualPort, ipVersion = version, resolved = resolved)
|
||||
}
|
||||
|
||||
val rendered = toString()
|
||||
return LyngSocketAddress(
|
||||
host = rendered,
|
||||
port = port ?: 0,
|
||||
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = resolved,
|
||||
)
|
||||
}
|
||||
|
||||
private fun InetAddress.toLyngSocketAddress(port: Int, resolved: Boolean): LyngSocketAddress =
|
||||
LyngSocketAddress(
|
||||
host = hostAddress,
|
||||
port = port,
|
||||
ipVersion = when (this) {
|
||||
is Inet6Address -> LyngIpVersion.IPV6
|
||||
else -> LyngIpVersion.IPV4
|
||||
},
|
||||
resolved = resolved,
|
||||
)
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.cio.CIO
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(CIO)
|
||||
@@ -0,0 +1,256 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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 com.sun.net.httpserver.HttpExchange
|
||||
import com.sun.net.httpserver.HttpServer
|
||||
import com.sun.net.httpserver.HttpsConfigurator
|
||||
import com.sun.net.httpserver.HttpsServer
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.flow
|
||||
import kotlinx.coroutines.flow.flowOn
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.io.http.createHttpModule
|
||||
import net.sergeych.lyng.io.net.createNetModule
|
||||
import net.sergeych.lyng.io.testtls.TlsTestMaterial
|
||||
import net.sergeych.lyng.io.ws.TestWebSocketServer
|
||||
import net.sergeych.lyng.io.ws.createWsModule
|
||||
import net.sergeych.lyng.leftMargin
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
|
||||
import java.net.InetSocketAddress
|
||||
import java.net.ServerSocket
|
||||
import java.nio.file.Files.readAllLines
|
||||
import java.nio.file.Paths
|
||||
import kotlin.concurrent.thread
|
||||
import kotlin.io.path.absolutePathString
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
data class IoDocTest(
|
||||
val fileName: String,
|
||||
val line: Int,
|
||||
val code: String,
|
||||
val expectedOutput: String,
|
||||
val expectedResult: String,
|
||||
) {
|
||||
val fileNamePart by lazy { Paths.get(fileName).fileName.toString() }
|
||||
|
||||
override fun toString(): String = "DocTest: ${Paths.get(fileName).absolutePathString()}:${line + 1}"
|
||||
}
|
||||
|
||||
private fun parseIoDocTests(fileName: String): Flow<IoDocTest> = flow {
|
||||
val book = readAllLines(Paths.get(fileName))
|
||||
var startOffset = 0
|
||||
val block = mutableListOf<String>()
|
||||
var startIndex = 0
|
||||
for ((index, l) in book.withIndex()) {
|
||||
val off = leftMargin(l)
|
||||
when {
|
||||
off < startOffset && startOffset != 0 -> {
|
||||
if (l.isBlank()) continue
|
||||
if (block.size > 1) {
|
||||
for ((i, s) in block.withIndex()) {
|
||||
var x = s
|
||||
val initial = leftMargin(x)
|
||||
do {
|
||||
x = x.drop(1)
|
||||
} while (initial - leftMargin(x) != startOffset)
|
||||
block[i] = x
|
||||
}
|
||||
val outStart = block.indexOfFirst { it.startsWith(">>>") }
|
||||
if (outStart >= 0) {
|
||||
val result = mutableListOf<String>()
|
||||
while (block.lastOrNull()?.isEmpty() == true) block.removeLast()
|
||||
var valid = true
|
||||
while (block.size > outStart) {
|
||||
val line = block.removeAt(outStart)
|
||||
if (!line.startsWith(">>> ")) {
|
||||
valid = false
|
||||
break
|
||||
}
|
||||
result.add(line.drop(4))
|
||||
}
|
||||
if (valid) {
|
||||
emit(
|
||||
IoDocTest(
|
||||
fileName = fileName,
|
||||
line = startIndex,
|
||||
code = block.joinToString("\n"),
|
||||
expectedOutput = if (result.size > 1) result.dropLast(1).joinToString("") { "$it\n" } else "",
|
||||
expectedResult = result.last(),
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
block.clear()
|
||||
startOffset = 0
|
||||
}
|
||||
|
||||
off != 0 && startOffset == 0 -> {
|
||||
block.clear()
|
||||
startIndex = index
|
||||
block.add(l)
|
||||
startOffset = off
|
||||
}
|
||||
|
||||
off != 0 -> block.add(l)
|
||||
}
|
||||
}
|
||||
}.flowOn(Dispatchers.IO)
|
||||
|
||||
private suspend fun IoDocTest.run(scope: Scope) {
|
||||
val output = StringBuilder()
|
||||
scope.addFn("println") {
|
||||
for ((i, a) in args.withIndex()) {
|
||||
if (i > 0) output.append(' ')
|
||||
output.append(toStringOf(a).value)
|
||||
}
|
||||
output.append('\n')
|
||||
ObjVoid
|
||||
}
|
||||
val result = scope.eval(code).inspect(scope).replace(Regex("@\\d+"), "@...")
|
||||
assertEquals(expectedOutput, output.toString(), "script output mismatch at $this")
|
||||
assertEquals(expectedResult, result, "script result mismatch at $this")
|
||||
}
|
||||
|
||||
private suspend fun runIoDocTests(
|
||||
fileName: String,
|
||||
installModules: suspend (Scope) -> Unit,
|
||||
installConsts: suspend (Scope) -> Unit = {},
|
||||
) {
|
||||
parseIoDocTests(fileName).collect { test ->
|
||||
val scope = Script.newScope()
|
||||
installModules(scope)
|
||||
installConsts(scope)
|
||||
test.run(scope)
|
||||
}
|
||||
}
|
||||
|
||||
class LyngioBookTest {
|
||||
|
||||
@Test
|
||||
fun testHttpDocs() = runBlocking {
|
||||
val server = newHttpServer(secure = false)
|
||||
val secureServer = newHttpServer(secure = true)
|
||||
try {
|
||||
runIoDocTests(
|
||||
fileName = "../docs/lyng.io.http.md",
|
||||
installModules = { scope -> createHttpModule(PermitAllHttpAccessPolicy, scope) },
|
||||
installConsts = { scope ->
|
||||
scope.addConst("HTTP_TEST_URL", ObjString("http://127.0.0.1:${server.address.port}"))
|
||||
scope.addConst("HTTPS_TEST_URL", ObjString("https://127.0.0.1:${secureServer.address.port}"))
|
||||
},
|
||||
)
|
||||
} finally {
|
||||
server.stop(0)
|
||||
secureServer.stop(0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testNetDocs() = runBlocking {
|
||||
ServerSocket(0, 50).use { server ->
|
||||
val worker = thread(start = true) {
|
||||
server.accept().use { client ->
|
||||
val line = client.getInputStream().readNBytes(4).decodeToString()
|
||||
client.getOutputStream().write(("reply:" + line).toByteArray())
|
||||
client.getOutputStream().flush()
|
||||
}
|
||||
}
|
||||
try {
|
||||
runIoDocTests(
|
||||
fileName = "../docs/lyng.io.net.md",
|
||||
installModules = { scope -> createNetModule(PermitAllNetAccessPolicy, scope) },
|
||||
installConsts = { scope -> scope.addConst("NET_TEST_TCP_PORT", ObjInt(server.localPort.toLong())) },
|
||||
)
|
||||
} finally {
|
||||
worker.join(2000)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testWsDocs() = runBlocking {
|
||||
TestWebSocketServer { connection ->
|
||||
val text = connection.receiveText()
|
||||
connection.sendText("echo:$text")
|
||||
connection.close()
|
||||
}.use { textServer ->
|
||||
TestWebSocketServer { connection ->
|
||||
val data = connection.receiveBinary()
|
||||
connection.sendBinary(byteArrayOf(1, 2, 3) + data)
|
||||
connection.close()
|
||||
}.use { binaryServer ->
|
||||
TestWebSocketServer(secure = true) { connection ->
|
||||
val text = connection.receiveText()
|
||||
connection.sendText("secure:$text")
|
||||
connection.close()
|
||||
}.use { secureServer ->
|
||||
runIoDocTests(
|
||||
fileName = "../docs/lyng.io.ws.md",
|
||||
installModules = { scope -> createWsModule(PermitAllWsAccessPolicy, scope) },
|
||||
installConsts = { scope ->
|
||||
scope.addConst("WS_TEST_URL", ObjString(textServer.url))
|
||||
scope.addConst("WS_TEST_BINARY_URL", ObjString(binaryServer.url))
|
||||
scope.addConst("WSS_TEST_URL", ObjString(secureServer.url))
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
|
||||
val bytes = body.toByteArray()
|
||||
exchange.sendResponseHeaders(status, bytes.size.toLong())
|
||||
exchange.responseBody.use { it.write(bytes) }
|
||||
}
|
||||
|
||||
private fun newHttpServer(secure: Boolean): HttpServer {
|
||||
if (secure) TlsTestMaterial.installJvmClientTrust()
|
||||
val server = if (secure) {
|
||||
HttpsServer.create(InetSocketAddress("127.0.0.1", 0), 0).apply {
|
||||
httpsConfigurator = HttpsConfigurator(TlsTestMaterial.sslContext)
|
||||
}
|
||||
} else {
|
||||
HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
|
||||
}
|
||||
server.createContext("/hello") { exchange ->
|
||||
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
|
||||
writeResponse(exchange, 200, "hello from test")
|
||||
}
|
||||
server.createContext("/headers") { exchange ->
|
||||
exchange.responseHeaders.add("X-Reply", "one")
|
||||
exchange.responseHeaders.add("X-Reply", "two")
|
||||
writeResponse(exchange, 200, "header demo")
|
||||
}
|
||||
server.createContext("/echo") { exchange ->
|
||||
val body = exchange.requestBody.readBytes().decodeToString()
|
||||
writeResponse(exchange, 200, exchange.requestMethod + ":" + body)
|
||||
}
|
||||
server.start()
|
||||
return server
|
||||
}
|
||||
}
|
||||
@@ -22,16 +22,14 @@ import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjIllegalOperationException
|
||||
import net.sergeych.lyngio.console.*
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessOp
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertIs
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.*
|
||||
|
||||
class LyngConsoleModuleTest {
|
||||
|
||||
@@ -56,7 +54,7 @@ class LyngConsoleModuleTest {
|
||||
val d = Console.details()
|
||||
assert(d.supported is Bool)
|
||||
assert(d.isTty is Bool)
|
||||
assert(d.ansiLevel is String)
|
||||
assert(d.ansiLevel is ConsoleAnsiLevel)
|
||||
|
||||
val g = Console.geometry()
|
||||
if (g != null) {
|
||||
@@ -112,4 +110,63 @@ class LyngConsoleModuleTest {
|
||||
assertIs<ObjIllegalOperationException>(error.errorObject)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun eventsIteratorRecoversAfterSourceFailure() = runBlocking {
|
||||
val scope = newScope()
|
||||
var eventsCalls = 0
|
||||
val console = object : LyngConsole {
|
||||
override val isSupported: Boolean = true
|
||||
|
||||
override suspend fun isTty(): Boolean = true
|
||||
|
||||
override suspend fun geometry(): ConsoleGeometry? = null
|
||||
|
||||
override suspend fun ansiLevel(): ConsoleAnsiLevel = ConsoleAnsiLevel.NONE
|
||||
|
||||
override suspend fun write(text: String) {}
|
||||
|
||||
override suspend fun flush() {}
|
||||
|
||||
override fun events(): ConsoleEventSource {
|
||||
eventsCalls += 1
|
||||
val callNo = eventsCalls
|
||||
return object : ConsoleEventSource {
|
||||
private var emitted = false
|
||||
|
||||
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
|
||||
if (emitted) return null
|
||||
emitted = true
|
||||
return when (callNo) {
|
||||
1 -> throw IllegalStateException("synthetic source failure")
|
||||
else -> ConsoleEvent.KeyDown(key = "x")
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun close() {}
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun setRawMode(enabled: Boolean): Boolean = enabled
|
||||
}
|
||||
|
||||
assertTrue(createConsoleModule(PermitAllConsoleAccessPolicy, scope.importManager, console))
|
||||
|
||||
val result = scope.eval(
|
||||
"""
|
||||
import lyng.io.console
|
||||
|
||||
val it = Console.events().iterator()
|
||||
assert(it.hasNext())
|
||||
val ev = it.next()
|
||||
assert(ev is ConsoleKeyEvent)
|
||||
assert((ev as ConsoleKeyEvent).key == "x")
|
||||
true
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
assertIs<ObjBool>(result)
|
||||
assertTrue(result.value)
|
||||
assertEquals(2, eventsCalls)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.http
|
||||
|
||||
import com.sun.net.httpserver.HttpExchange
|
||||
import com.sun.net.httpserver.HttpServer
|
||||
import com.sun.net.httpserver.HttpsConfigurator
|
||||
import com.sun.net.httpserver.HttpsServer
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.io.testtls.TlsTestMaterial
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.http.security.HttpAccessOp
|
||||
import net.sergeych.lyngio.http.security.HttpAccessPolicy
|
||||
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
|
||||
import java.net.InetSocketAddress
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertFailsWith
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class LyngHttpModuleTest {
|
||||
|
||||
@Test
|
||||
fun testConvenienceGetAndHeaders() = runBlocking {
|
||||
val server = newServer { exchange ->
|
||||
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
|
||||
exchange.responseHeaders.add("X-Reply", "one")
|
||||
exchange.responseHeaders.add("X-Reply", "two")
|
||||
writeResponse(exchange, 200, "hello from test")
|
||||
}
|
||||
try {
|
||||
val scope = Script.newScope()
|
||||
createHttpModule(PermitAllHttpAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.http
|
||||
|
||||
val r = Http.get(
|
||||
"http://127.0.0.1:${server.address.port}/hello",
|
||||
"Accept" => "text/plain",
|
||||
"X-Test" => "yes"
|
||||
)
|
||||
[r.status, r.headers["Content-Type"], r.headers.getAll("X-Reply").size, r.text()]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope)
|
||||
val rendered = result.inspect(scope)
|
||||
assertTrue(rendered.contains("200"), rendered)
|
||||
assertTrue(rendered.contains("text/plain"), rendered)
|
||||
assertTrue(rendered.contains("2"), rendered)
|
||||
assertTrue(rendered.contains("hello from test"), rendered)
|
||||
} finally {
|
||||
server.stop(0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testMutableRequestPost() = runBlocking {
|
||||
val server = newServer { exchange ->
|
||||
val body = exchange.requestBody.readBytes().decodeToString()
|
||||
exchange.responseHeaders.add("Content-Type", "text/plain")
|
||||
writeResponse(exchange, 200, exchange.requestMethod + ":" + body)
|
||||
}
|
||||
try {
|
||||
val scope = Script.newScope()
|
||||
createHttpModule(PermitAllHttpAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.http
|
||||
|
||||
val q = HttpRequest()
|
||||
q.method = "POST"
|
||||
q.url = "http://127.0.0.1:${server.address.port}/echo"
|
||||
q.headers = Map("Content-Type" => "text/plain")
|
||||
q.bodyText = "ping"
|
||||
|
||||
val r = Http.request(q)
|
||||
r.text()
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope)
|
||||
assertTrue(result.inspect(scope).contains("POST:ping"))
|
||||
} finally {
|
||||
server.stop(0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testHttpsGet() = runBlocking {
|
||||
TlsTestMaterial.installJvmClientTrust()
|
||||
val server = newServer(secure = true) { exchange ->
|
||||
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
|
||||
writeResponse(exchange, 200, "hello over tls")
|
||||
}
|
||||
try {
|
||||
val scope = Script.newScope()
|
||||
createHttpModule(PermitAllHttpAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.http
|
||||
|
||||
val r = Http.get("https://127.0.0.1:${server.address.port}/hello")
|
||||
[r.status, r.text()]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope)
|
||||
val rendered = result.inspect(scope)
|
||||
assertTrue(rendered.contains("200"), rendered)
|
||||
assertTrue(rendered.contains("hello over tls"), rendered)
|
||||
} finally {
|
||||
server.stop(0)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
val denyAll = object : HttpAccessPolicy {
|
||||
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Deny, "blocked by test policy")
|
||||
}
|
||||
createHttpModule(denyAll, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.http
|
||||
Http.get("http://127.0.0.1:1/")
|
||||
""".trimIndent()
|
||||
|
||||
val error = assertFailsWith<ExecutionError> {
|
||||
Compiler.compile(code).execute(scope)
|
||||
}
|
||||
assertTrue(error.errorMessage.isNotBlank())
|
||||
}
|
||||
|
||||
private fun newServer(secure: Boolean = false, handler: (HttpExchange) -> Unit): HttpServer {
|
||||
val server = if (secure) {
|
||||
HttpsServer.create(InetSocketAddress("127.0.0.1", 0), 0).apply {
|
||||
httpsConfigurator = HttpsConfigurator(TlsTestMaterial.sslContext)
|
||||
}
|
||||
} else {
|
||||
HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
|
||||
}
|
||||
server.createContext("/") { exchange ->
|
||||
handler(exchange)
|
||||
}
|
||||
server.start()
|
||||
return server
|
||||
}
|
||||
|
||||
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
|
||||
val bytes = body.toByteArray()
|
||||
exchange.sendResponseHeaders(status, bytes.size.toLong())
|
||||
exchange.responseBody.use { out ->
|
||||
out.write(bytes)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.net
|
||||
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import kotlinx.coroutines.withContext
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.net.security.NetAccessOp
|
||||
import net.sergeych.lyngio.net.security.NetAccessPolicy
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import java.net.DatagramPacket
|
||||
import java.net.DatagramSocket
|
||||
import java.net.ServerSocket
|
||||
import java.net.Socket
|
||||
import kotlin.concurrent.thread
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertFailsWith
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class LyngNetModuleTest {
|
||||
|
||||
@Test
|
||||
fun testResolveAndCapabilities() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.net
|
||||
|
||||
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
|
||||
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("true,true,true,true"), result)
|
||||
assertTrue(result.contains("127.0.0.1:4040"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testTcpConnectConvenience() = runBlocking {
|
||||
ServerSocket(0, 50).use { server ->
|
||||
val worker = thread(start = true) {
|
||||
server.accept().use { client ->
|
||||
val line = client.getInputStream().readNBytes(4).decodeToString()
|
||||
client.getOutputStream().write(("reply:" + line).toByteArray())
|
||||
client.getOutputStream().flush()
|
||||
}
|
||||
}
|
||||
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", ${server.localPort})
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
val localPort = socket.localAddress().port
|
||||
val remotePort = socket.remoteAddress().port
|
||||
socket.close()
|
||||
[reply, localPort > 0, remotePort == ${server.localPort}]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
worker.join(2000)
|
||||
assertTrue(result.contains("reply:ping"), result)
|
||||
assertTrue(result.contains("true,true"), result)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testTcpListenAndAcceptInLyng() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.tcpListen(0, "127.0.0.1")
|
||||
val port = server.localAddress().port
|
||||
val accepted = launch {
|
||||
val client = server.accept()
|
||||
val line = (client.read(4) as Buffer).decodeUtf8()
|
||||
client.writeUtf8("echo:" + line)
|
||||
client.flush()
|
||||
client.close()
|
||||
server.close()
|
||||
line
|
||||
}
|
||||
|
||||
val socket = Net.tcpConnect("127.0.0.1", port)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = (socket.read(16) as Buffer).decodeUtf8()
|
||||
socket.close()
|
||||
[accepted.await(), reply]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("[ping,echo:ping]"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testUdpLoopback() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.net
|
||||
|
||||
val server = Net.udpBind(0, "127.0.0.1")
|
||||
val client = Net.udpBind(0, "127.0.0.1")
|
||||
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
|
||||
val d = server.receive()
|
||||
client.close()
|
||||
server.close()
|
||||
[d.data.decodeUtf8(), d.address.port > 0]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("[ping,true]"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
val denyAll = object : NetAccessPolicy {
|
||||
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Deny, "blocked by test policy")
|
||||
}
|
||||
createNetModule(denyAll, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.net
|
||||
Net.tcpConnect("127.0.0.1", 1)
|
||||
""".trimIndent()
|
||||
|
||||
val error = assertFailsWith<ExecutionError> {
|
||||
Compiler.compile(code).execute(scope)
|
||||
}
|
||||
assertTrue(error.errorMessage.isNotBlank())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.testtls
|
||||
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.Path
|
||||
import java.security.KeyStore
|
||||
import javax.net.ssl.KeyManagerFactory
|
||||
import javax.net.ssl.SSLContext
|
||||
import javax.net.ssl.SSLServerSocketFactory
|
||||
import javax.net.ssl.TrustManagerFactory
|
||||
import kotlin.io.path.absolutePathString
|
||||
|
||||
internal object TlsTestMaterial {
|
||||
private const val STORE_PASSWORD = "changeit"
|
||||
private const val KEY_ALIAS = "lyng-io-test"
|
||||
|
||||
private val dir: Path by lazy { Files.createTempDirectory("lyng-io-tls-test-") }
|
||||
private val serverStore: Path by lazy { dir.resolve("server.p12") }
|
||||
private val trustStore: Path by lazy { dir.resolve("trust.p12") }
|
||||
private val certFile: Path by lazy { dir.resolve("server.cer") }
|
||||
|
||||
val serverSocketFactory: SSLServerSocketFactory by lazy {
|
||||
ensureGenerated()
|
||||
val keyStore = KeyStore.getInstance("PKCS12")
|
||||
serverStore.toFile().inputStream().use { keyStore.load(it, STORE_PASSWORD.toCharArray()) }
|
||||
val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
|
||||
kmf.init(keyStore, STORE_PASSWORD.toCharArray())
|
||||
SSLContext.getInstance("TLS").apply {
|
||||
init(kmf.keyManagers, null, null)
|
||||
}.serverSocketFactory
|
||||
}
|
||||
|
||||
val sslContext: SSLContext by lazy {
|
||||
ensureGenerated()
|
||||
val keyStore = KeyStore.getInstance("PKCS12")
|
||||
serverStore.toFile().inputStream().use { keyStore.load(it, STORE_PASSWORD.toCharArray()) }
|
||||
val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
|
||||
kmf.init(keyStore, STORE_PASSWORD.toCharArray())
|
||||
val trust = KeyStore.getInstance("PKCS12")
|
||||
trustStore.toFile().inputStream().use { trust.load(it, STORE_PASSWORD.toCharArray()) }
|
||||
val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
|
||||
tmf.init(trust)
|
||||
SSLContext.getInstance("TLS").apply {
|
||||
init(kmf.keyManagers, tmf.trustManagers, null)
|
||||
}
|
||||
}
|
||||
|
||||
fun installJvmClientTrust() {
|
||||
ensureGenerated()
|
||||
System.setProperty("javax.net.ssl.trustStore", trustStore.absolutePathString())
|
||||
System.setProperty("javax.net.ssl.trustStorePassword", STORE_PASSWORD)
|
||||
System.setProperty("javax.net.ssl.trustStoreType", "PKCS12")
|
||||
|
||||
val trust = KeyStore.getInstance("PKCS12")
|
||||
trustStore.toFile().inputStream().use { trust.load(it, STORE_PASSWORD.toCharArray()) }
|
||||
val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
|
||||
tmf.init(trust)
|
||||
SSLContext.setDefault(
|
||||
SSLContext.getInstance("TLS").apply {
|
||||
init(null, tmf.trustManagers, null)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
private fun ensureGenerated() {
|
||||
if (Files.exists(serverStore) && Files.exists(trustStore) && Files.exists(certFile)) return
|
||||
runKeytool(
|
||||
"-genkeypair",
|
||||
"-alias", KEY_ALIAS,
|
||||
"-keyalg", "RSA",
|
||||
"-keysize", "2048",
|
||||
"-validity", "2",
|
||||
"-storetype", "PKCS12",
|
||||
"-keystore", serverStore.absolutePathString(),
|
||||
"-storepass", STORE_PASSWORD,
|
||||
"-keypass", STORE_PASSWORD,
|
||||
"-dname", "CN=127.0.0.1, OU=Lyng, O=Lyng, L=Test, ST=Test, C=US",
|
||||
"-ext", "SAN=ip:127.0.0.1,dns:localhost",
|
||||
)
|
||||
runKeytool(
|
||||
"-exportcert",
|
||||
"-alias", KEY_ALIAS,
|
||||
"-keystore", serverStore.absolutePathString(),
|
||||
"-storepass", STORE_PASSWORD,
|
||||
"-rfc",
|
||||
"-file", certFile.absolutePathString(),
|
||||
)
|
||||
runKeytool(
|
||||
"-importcert",
|
||||
"-noprompt",
|
||||
"-alias", KEY_ALIAS,
|
||||
"-storetype", "PKCS12",
|
||||
"-keystore", trustStore.absolutePathString(),
|
||||
"-storepass", STORE_PASSWORD,
|
||||
"-file", certFile.absolutePathString(),
|
||||
)
|
||||
}
|
||||
|
||||
private fun runKeytool(vararg args: String) {
|
||||
val process = ProcessBuilder(listOf("keytool") + args)
|
||||
.redirectErrorStream(true)
|
||||
.start()
|
||||
val output = process.inputStream.bufferedReader().readText()
|
||||
val code = process.waitFor()
|
||||
require(code == 0) { "keytool failed: $output" }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.ws
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
|
||||
import net.sergeych.lyngio.ws.security.WsAccessOp
|
||||
import net.sergeych.lyngio.ws.security.WsAccessPolicy
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFailsWith
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class LyngWsModuleTest {
|
||||
|
||||
@Test
|
||||
fun testTextSessionAndHeaders() = runBlocking {
|
||||
TestWebSocketServer { connection ->
|
||||
assertEquals("yes", connection.requestHeaders["x-test"])
|
||||
val text = connection.receiveText()
|
||||
connection.sendText("echo:$text")
|
||||
connection.close()
|
||||
}.use { server ->
|
||||
val scope = Script.newScope()
|
||||
createWsModule(PermitAllWsAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect("${server.url}", "X-Test" => "yes")
|
||||
ws.sendText("ping")
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[ws.url(), m.isText, m.text]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains(server.url), result)
|
||||
assertTrue(result.contains("true,echo:ping"), result)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBinarySession() = runBlocking {
|
||||
TestWebSocketServer { connection ->
|
||||
val data = connection.receiveBinary()
|
||||
connection.sendBinary(byteArrayOf(1, 2, 3) + data)
|
||||
connection.close()
|
||||
}.use { server ->
|
||||
val scope = Script.newScope()
|
||||
createWsModule(PermitAllWsAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.buffer
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect("${server.url}")
|
||||
ws.sendBytes(Buffer(9, 8, 7))
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[m.isText, (m.data as Buffer).hex]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("false,010203090807"), result)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSecureTextSession() = runBlocking {
|
||||
TestWebSocketServer(secure = true) { connection ->
|
||||
val text = connection.receiveText()
|
||||
connection.sendText("secure:$text")
|
||||
connection.close()
|
||||
}.use { server ->
|
||||
val scope = Script.newScope()
|
||||
createWsModule(PermitAllWsAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.ws
|
||||
|
||||
val ws = Ws.connect("${server.url}")
|
||||
ws.sendText("ping")
|
||||
val m: WsMessage = ws.receive()
|
||||
ws.close()
|
||||
[ws.url(), m.text]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains(server.url), result)
|
||||
assertTrue(result.contains("secure:ping"), result)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
val denyAll = object : WsAccessPolicy {
|
||||
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
|
||||
AccessDecision(Decision.Deny, "blocked by test policy")
|
||||
}
|
||||
createWsModule(denyAll, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.ws
|
||||
Ws.connect("ws://127.0.0.1:1/ws")
|
||||
""".trimIndent()
|
||||
|
||||
val error = assertFailsWith<ExecutionError> {
|
||||
Compiler.compile(code).execute(scope)
|
||||
}
|
||||
assertTrue(error.errorMessage.isNotBlank())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.ws
|
||||
|
||||
import net.sergeych.lyng.io.testtls.TlsTestMaterial
|
||||
import java.io.BufferedInputStream
|
||||
import java.io.BufferedOutputStream
|
||||
import java.net.InetAddress
|
||||
import java.net.ServerSocket
|
||||
import java.net.Socket
|
||||
import java.security.MessageDigest
|
||||
import java.util.Base64
|
||||
import kotlin.concurrent.thread
|
||||
|
||||
internal class TestWebSocketServer(
|
||||
secure: Boolean = false,
|
||||
private val handler: (TestWebSocketConnection) -> Unit,
|
||||
) : AutoCloseable {
|
||||
private val server: ServerSocket = if (secure) {
|
||||
TlsTestMaterial.installJvmClientTrust()
|
||||
TlsTestMaterial.serverSocketFactory.createServerSocket(0, 50, InetAddress.getByName("127.0.0.1")) as ServerSocket
|
||||
} else {
|
||||
ServerSocket(0, 50, InetAddress.getByName("127.0.0.1"))
|
||||
}
|
||||
private val scheme = if (secure) "wss" else "ws"
|
||||
private val worker = thread(start = true, name = "ws-test-server") {
|
||||
try {
|
||||
server.accept().use { socket ->
|
||||
val connection = TestWebSocketConnection(socket)
|
||||
connection.handshake()
|
||||
handler(connection)
|
||||
}
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
}
|
||||
|
||||
val url: String = "$scheme://127.0.0.1:${server.localPort}/ws"
|
||||
|
||||
override fun close() {
|
||||
server.close()
|
||||
worker.join(2000)
|
||||
}
|
||||
}
|
||||
|
||||
internal class TestWebSocketConnection(socket: Socket) {
|
||||
private val input = BufferedInputStream(socket.getInputStream())
|
||||
private val output = BufferedOutputStream(socket.getOutputStream())
|
||||
val requestHeaders = linkedMapOf<String, String>()
|
||||
|
||||
fun handshake() {
|
||||
val requestLine = input.readAsciiLine() ?: error("missing websocket request line")
|
||||
require(requestLine.startsWith("GET ")) { "unexpected request: $requestLine" }
|
||||
while (true) {
|
||||
val line = input.readAsciiLine() ?: error("unexpected EOF during websocket handshake")
|
||||
if (line.isEmpty()) break
|
||||
val colon = line.indexOf(':')
|
||||
if (colon > 0) {
|
||||
requestHeaders[line.substring(0, colon).trim().lowercase()] = line.substring(colon + 1).trim()
|
||||
}
|
||||
}
|
||||
val key = requestHeaders["sec-websocket-key"] ?: error("missing Sec-WebSocket-Key")
|
||||
val accept = Base64.getEncoder().encodeToString(
|
||||
MessageDigest.getInstance("SHA-1")
|
||||
.digest((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").toByteArray())
|
||||
)
|
||||
output.write(
|
||||
(
|
||||
"HTTP/1.1 101 Switching Protocols\r\n" +
|
||||
"Upgrade: websocket\r\n" +
|
||||
"Connection: Upgrade\r\n" +
|
||||
"Sec-WebSocket-Accept: $accept\r\n" +
|
||||
"\r\n"
|
||||
).toByteArray()
|
||||
)
|
||||
output.flush()
|
||||
}
|
||||
|
||||
fun receiveText(): String = receiveFrame().let { frame ->
|
||||
require(frame.opcode == 0x1) { "expected text frame, got opcode=${frame.opcode}" }
|
||||
frame.payload.decodeToString()
|
||||
}
|
||||
|
||||
fun receiveBinary(): ByteArray = receiveFrame().let { frame ->
|
||||
require(frame.opcode == 0x2) { "expected binary frame, got opcode=${frame.opcode}" }
|
||||
frame.payload
|
||||
}
|
||||
|
||||
fun sendText(text: String) {
|
||||
sendFrame(0x1, text.encodeToByteArray())
|
||||
}
|
||||
|
||||
fun sendBinary(data: ByteArray) {
|
||||
sendFrame(0x2, data)
|
||||
}
|
||||
|
||||
fun close(code: Int = 1000, reason: String = "") {
|
||||
val reasonBytes = reason.encodeToByteArray()
|
||||
val payload = ByteArray(2 + reasonBytes.size)
|
||||
payload[0] = ((code shr 8) and 0xff).toByte()
|
||||
payload[1] = (code and 0xff).toByte()
|
||||
reasonBytes.copyInto(payload, 2)
|
||||
sendFrame(0x8, payload)
|
||||
}
|
||||
|
||||
private fun sendFrame(opcode: Int, payload: ByteArray) {
|
||||
output.write(0x80 or opcode)
|
||||
when {
|
||||
payload.size < 126 -> output.write(payload.size)
|
||||
payload.size <= 0xffff -> {
|
||||
output.write(126)
|
||||
output.write((payload.size ushr 8) and 0xff)
|
||||
output.write(payload.size and 0xff)
|
||||
}
|
||||
else -> error("payload too large for test websocket server")
|
||||
}
|
||||
output.write(payload)
|
||||
output.flush()
|
||||
}
|
||||
|
||||
private fun receiveFrame(): IncomingFrame {
|
||||
val b0 = input.read()
|
||||
require(b0 >= 0) { "unexpected EOF reading websocket frame" }
|
||||
val b1 = input.read()
|
||||
require(b1 >= 0) { "unexpected EOF reading websocket frame length" }
|
||||
val opcode = b0 and 0x0f
|
||||
var length = b1 and 0x7f
|
||||
if (length == 126) {
|
||||
length = (input.read() shl 8) or input.read()
|
||||
} else if (length == 127) {
|
||||
error("64-bit websocket lengths are not supported in tests")
|
||||
}
|
||||
val masked = (b1 and 0x80) != 0
|
||||
val mask = if (masked) ByteArray(4).also { input.readFully(it) } else null
|
||||
val payload = ByteArray(length)
|
||||
input.readFully(payload)
|
||||
if (mask != null) {
|
||||
for (i in payload.indices) payload[i] = (payload[i].toInt() xor mask[i % 4].toInt()).toByte()
|
||||
}
|
||||
return IncomingFrame(opcode, payload)
|
||||
}
|
||||
}
|
||||
|
||||
private data class IncomingFrame(val opcode: Int, val payload: ByteArray)
|
||||
|
||||
private fun BufferedInputStream.readAsciiLine(): String? {
|
||||
val out = StringBuilder()
|
||||
while (true) {
|
||||
val b = read()
|
||||
if (b < 0) return if (out.isEmpty()) null else out.toString()
|
||||
if (b == '\n'.code) {
|
||||
if (out.endsWith("\r")) out.setLength(out.length - 1)
|
||||
return out.toString()
|
||||
}
|
||||
out.append(b.toChar())
|
||||
}
|
||||
}
|
||||
|
||||
private fun BufferedInputStream.readFully(target: ByteArray) {
|
||||
var offset = 0
|
||||
while (offset < target.size) {
|
||||
val read = read(target, offset, target.size - offset)
|
||||
require(read > 0) { "unexpected EOF" }
|
||||
offset += read
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.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.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class JvmConsoleKeyDecoderTest {
|
||||
|
||||
private fun decode(vararg bytes: Int): ConsoleEvent.KeyDown {
|
||||
var index = 1
|
||||
return JvmConsoleKeyDecoder.decode(bytes[0]) { _ ->
|
||||
if (index >= bytes.size) null else bytes[index++]
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun decodesArrowLeft() {
|
||||
val ev = decode(27, '['.code, 'D'.code)
|
||||
assertEquals("ArrowLeft", ev.key)
|
||||
assertFalse(ev.ctrl)
|
||||
assertFalse(ev.alt)
|
||||
assertFalse(ev.shift)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun decodesCtrlArrowRightModifier() {
|
||||
val ev = decode(27, '['.code, '1'.code, ';'.code, '5'.code, 'C'.code)
|
||||
assertEquals("ArrowRight", ev.key)
|
||||
assertTrue(ev.ctrl)
|
||||
assertFalse(ev.alt)
|
||||
assertFalse(ev.shift)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun decodesAltCharacter() {
|
||||
val ev = decode(27, 'x'.code)
|
||||
assertEquals("x", ev.key)
|
||||
assertTrue(ev.alt)
|
||||
assertFalse(ev.ctrl)
|
||||
}
|
||||
}
|
||||
@@ -22,11 +22,14 @@ import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import platform.posix.*
|
||||
import kotlin.time.Duration.Companion.milliseconds
|
||||
import kotlin.time.TimeSource
|
||||
|
||||
internal actual fun getNativeSystemConsole(): LyngConsole = LinuxPosixLyngConsole
|
||||
|
||||
private const val RAW_IDLE_POLL_MS = 10L
|
||||
private const val NON_RAW_IDLE_POLL_MS = 25L
|
||||
private const val ESCAPE_FOLLOWUP_TIMEOUT_MS = 25L
|
||||
|
||||
internal object LinuxConsoleKeyDecoder {
|
||||
fun decode(firstCode: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
|
||||
if (firstCode == 27) {
|
||||
@@ -132,6 +135,7 @@ object LinuxPosixLyngConsole : LyngConsole {
|
||||
}
|
||||
}
|
||||
|
||||
consoleFlowDebug("linux-events: source created")
|
||||
return object : ConsoleEventSource {
|
||||
var closed = false
|
||||
var lastGeometry: ConsoleGeometry? = null
|
||||
@@ -147,23 +151,27 @@ object LinuxPosixLyngConsole : LyngConsole {
|
||||
}
|
||||
|
||||
val rawRequested = stateMutex.withLock { rawModeRequested }
|
||||
val pollSliceMs = if (timeoutMs <= 0L) 250L else minOf(250L, timeoutMs)
|
||||
if (rawRequested) {
|
||||
val ev = readKeyEvent(pollSliceMs)
|
||||
val ev = readKeyEventNonBlocking()
|
||||
if (ev != null) return ev
|
||||
} else {
|
||||
delay(25)
|
||||
}
|
||||
|
||||
if (timeoutMs > 0L && started.elapsedNow() >= timeoutMs.milliseconds) {
|
||||
val elapsedMs = started.elapsedNow().inWholeMilliseconds
|
||||
if (timeoutMs > 0L && elapsedMs >= timeoutMs) {
|
||||
return null
|
||||
}
|
||||
|
||||
val remainingMs = if (timeoutMs > 0L) timeoutMs - elapsedMs else Long.MAX_VALUE
|
||||
val idleMs = if (rawRequested) RAW_IDLE_POLL_MS else NON_RAW_IDLE_POLL_MS
|
||||
val sleepMs = if (timeoutMs > 0L) minOf(idleMs, remainingMs) else idleMs
|
||||
if (sleepMs > 0L) delay(sleepMs)
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
override suspend fun close() {
|
||||
closed = true
|
||||
consoleFlowDebug("linux-events: source closed")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -183,12 +191,11 @@ object LinuxPosixLyngConsole : LyngConsole {
|
||||
}
|
||||
savedAttrsBlob = saved
|
||||
|
||||
attrs.c_lflag = attrs.c_lflag and ICANON.convert<UInt>().inv() and ECHO.convert<UInt>().inv()
|
||||
attrs.c_iflag = attrs.c_iflag and IXON.convert<UInt>().inv() and ISTRIP.convert<UInt>().inv()
|
||||
attrs.c_oflag = attrs.c_oflag and OPOST.convert<UInt>().inv()
|
||||
configureRawInput(attrs)
|
||||
if (tcsetattr(STDIN_FILENO, TCSANOW, attrs.ptr) != 0) return@withLock false
|
||||
}
|
||||
rawModeRequested = true
|
||||
consoleFlowDebug("linux-events: setRawMode(true): enabled")
|
||||
true
|
||||
} else {
|
||||
val hadRaw = rawModeRequested
|
||||
@@ -203,6 +210,7 @@ object LinuxPosixLyngConsole : LyngConsole {
|
||||
tcsetattr(STDIN_FILENO, TCSANOW, attrs.ptr)
|
||||
}
|
||||
}
|
||||
consoleFlowDebug("linux-events: setRawMode(false): disabled hadRaw=$hadRaw")
|
||||
hadRaw
|
||||
}
|
||||
}
|
||||
@@ -225,19 +233,55 @@ object LinuxPosixLyngConsole : LyngConsole {
|
||||
val ready = poll(pfd.ptr, 1.convert(), timeoutMs.toInt())
|
||||
if (ready <= 0) return null
|
||||
|
||||
readReadyByte()
|
||||
}
|
||||
|
||||
private fun readReadyByte(): Int? {
|
||||
val buf = ByteArray(1)
|
||||
val count = buf.usePinned { pinned ->
|
||||
read(STDIN_FILENO, pinned.addressOf(0), 1.convert())
|
||||
}
|
||||
if (count <= 0) return null
|
||||
if (count <= 0) {
|
||||
if (count < 0) {
|
||||
consoleFlowDebug("linux-events: stdin read returned $count errno=$errno")
|
||||
}
|
||||
return null
|
||||
}
|
||||
val b = buf[0].toInt()
|
||||
if (b < 0) b + 256 else b
|
||||
return if (b < 0) b + 256 else b
|
||||
}
|
||||
|
||||
private fun readKeyEvent(timeoutMs: Long): ConsoleEvent.KeyDown? {
|
||||
val first = readByte(timeoutMs) ?: return null
|
||||
private fun readByteNow(): Int? = memScoped {
|
||||
val pfd = alloc<pollfd>()
|
||||
pfd.fd = STDIN_FILENO
|
||||
pfd.events = POLLIN.convert()
|
||||
pfd.revents = 0
|
||||
val ready = poll(pfd.ptr, 1.convert(), 0)
|
||||
if (ready <= 0) return null
|
||||
readReadyByte()
|
||||
}
|
||||
|
||||
private fun readKeyEventNonBlocking(): ConsoleEvent.KeyDown? {
|
||||
val first = readByteNow() ?: return null
|
||||
return LinuxConsoleKeyDecoder.decode(first) { timeout ->
|
||||
readByte(timeout)
|
||||
readByte(minOf(timeout, ESCAPE_FOLLOWUP_TIMEOUT_MS))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalForeignApi::class)
|
||||
internal fun configureRawInput(attrs: termios) {
|
||||
attrs.c_iflag = attrs.c_iflag and BRKINT.convert<UInt>().inv()
|
||||
attrs.c_iflag = attrs.c_iflag and ICRNL.convert<UInt>().inv()
|
||||
attrs.c_iflag = attrs.c_iflag and INPCK.convert<UInt>().inv()
|
||||
attrs.c_iflag = attrs.c_iflag and ISTRIP.convert<UInt>().inv()
|
||||
attrs.c_iflag = attrs.c_iflag and IXON.convert<UInt>().inv()
|
||||
attrs.c_oflag = attrs.c_oflag and OPOST.convert<UInt>().inv()
|
||||
attrs.c_cflag = attrs.c_cflag or CS8.convert<UInt>()
|
||||
attrs.c_lflag = attrs.c_lflag and ECHO.convert<UInt>().inv()
|
||||
attrs.c_lflag = attrs.c_lflag and ICANON.convert<UInt>().inv()
|
||||
attrs.c_lflag = attrs.c_lflag and IEXTEN.convert<UInt>().inv()
|
||||
attrs.c_lflag = attrs.c_lflag and ISIG.convert<UInt>().inv()
|
||||
attrs.c_cc[VMIN] = 0u
|
||||
attrs.c_cc[VTIME] = 1u
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.curl.Curl
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Curl)
|
||||
@@ -0,0 +1,8 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = createNativeKtorNetEngine(
|
||||
isSupported = true,
|
||||
isTcpAvailable = true,
|
||||
isTcpServerAvailable = true,
|
||||
isUdpAvailable = true,
|
||||
)
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.curl.Curl
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Curl)
|
||||
@@ -17,6 +17,8 @@
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
import kotlinx.cinterop.*
|
||||
import platform.posix.*
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
@@ -64,4 +66,41 @@ class LinuxPosixLyngConsoleTest {
|
||||
assertEquals("A", ev.key)
|
||||
assertTrue(ev.shift)
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalForeignApi::class)
|
||||
@Test
|
||||
fun configuresRawModeReadSemantics() = memScoped {
|
||||
val attrs = alloc<termios>()
|
||||
attrs.c_iflag =
|
||||
BRKINT.convert<UInt>() or
|
||||
ICRNL.convert<UInt>() or
|
||||
INPCK.convert<UInt>() or
|
||||
ISTRIP.convert<UInt>() or
|
||||
IXON.convert<UInt>()
|
||||
attrs.c_oflag = OPOST.convert<UInt>()
|
||||
attrs.c_cflag = 0u
|
||||
attrs.c_lflag =
|
||||
ECHO.convert<UInt>() or
|
||||
ICANON.convert<UInt>() or
|
||||
IEXTEN.convert<UInt>() or
|
||||
ISIG.convert<UInt>()
|
||||
attrs.c_cc[VMIN] = 9u
|
||||
attrs.c_cc[VTIME] = 9u
|
||||
|
||||
configureRawInput(attrs)
|
||||
|
||||
assertEquals(0u, attrs.c_iflag and BRKINT.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_iflag and ICRNL.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_iflag and INPCK.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_iflag and ISTRIP.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_iflag and IXON.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_oflag and OPOST.convert<UInt>())
|
||||
assertEquals(CS8.convert<UInt>(), attrs.c_cflag and CS8.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_lflag and ECHO.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_lflag and ICANON.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_lflag and IEXTEN.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_lflag and ISIG.convert<UInt>())
|
||||
assertEquals(0u, attrs.c_cc[VMIN].toUInt())
|
||||
assertEquals(1u, attrs.c_cc[VTIME].toUInt())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
import kotlinx.coroutines.async
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.io.net.createNetModule
|
||||
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class NetLinuxNativeTest {
|
||||
|
||||
@Test
|
||||
fun testLinuxNativeCapabilitiesAndResolve() = runBlocking {
|
||||
val engine = getSystemNetEngine()
|
||||
|
||||
assertTrue(engine.isSupported)
|
||||
assertTrue(engine.isTcpAvailable)
|
||||
assertTrue(engine.isTcpServerAvailable)
|
||||
assertTrue(engine.isUdpAvailable)
|
||||
|
||||
val resolved = engine.resolve("127.0.0.1", 4040)
|
||||
assertEquals(1, resolved.size)
|
||||
assertEquals("127.0.0.1", resolved.single().host)
|
||||
assertEquals(4040, resolved.single().port)
|
||||
assertEquals(LyngIpVersion.IPV4, resolved.single().ipVersion)
|
||||
assertTrue(resolved.single().resolved)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testLinuxNativeLyngModuleCapabilities() = runBlocking {
|
||||
val scope = Script.newScope()
|
||||
createNetModule(PermitAllNetAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.net
|
||||
|
||||
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
|
||||
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved]
|
||||
""".trimIndent()
|
||||
|
||||
val result = Compiler.compile(code).execute(scope).inspect(scope)
|
||||
assertTrue(result.contains("true,true,true,true"), result)
|
||||
assertTrue(result.contains("127.0.0.1:4040"), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testLinuxNativeTcpAndUdpLoopback() = runBlocking {
|
||||
val engine = getSystemNetEngine()
|
||||
|
||||
withTimeout(5_000) {
|
||||
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 16, reuseAddress = true)
|
||||
val accepted = async {
|
||||
val client = server.accept()
|
||||
val text = client.read(4)?.decodeToString()
|
||||
client.writeUtf8("echo:$text")
|
||||
client.flush()
|
||||
client.close()
|
||||
server.close()
|
||||
text
|
||||
}
|
||||
|
||||
val socket = engine.tcpConnect("127.0.0.1", server.localAddress().port, timeoutMillis = 2_000, noDelay = true)
|
||||
socket.writeUtf8("ping")
|
||||
socket.flush()
|
||||
val reply = socket.read(32)?.decodeToString()
|
||||
socket.close()
|
||||
|
||||
assertEquals("ping", accepted.await())
|
||||
assertEquals("echo:ping", reply)
|
||||
}
|
||||
|
||||
withTimeout(5_000) {
|
||||
val receiver = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
|
||||
val sender = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
|
||||
|
||||
sender.send("ping".encodeToByteArray(), "127.0.0.1", receiver.localAddress().port)
|
||||
val datagram = receiver.receive(32)
|
||||
|
||||
sender.close()
|
||||
receiver.close()
|
||||
|
||||
assertEquals("ping", datagram?.data?.decodeToString())
|
||||
assertTrue((datagram?.address?.port ?: 0) > 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.http
|
||||
|
||||
import io.ktor.client.engine.winhttp.WinHttp
|
||||
|
||||
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(WinHttp)
|
||||
@@ -0,0 +1,3 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
actual fun getSystemNetEngine(): LyngNetEngine = UnsupportedLyngNetEngine
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.sergeych.lyngio.ws
|
||||
|
||||
import io.ktor.client.engine.winhttp.WinHttp
|
||||
|
||||
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(WinHttp)
|
||||
@@ -17,6 +17,35 @@
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
import kotlinx.cinterop.ExperimentalForeignApi
|
||||
import kotlinx.cinterop.toKString
|
||||
import platform.posix.fclose
|
||||
import platform.posix.fopen
|
||||
import platform.posix.fputs
|
||||
import platform.posix.getenv
|
||||
|
||||
@OptIn(ExperimentalForeignApi::class)
|
||||
private val flowDebugLogFilePath: String
|
||||
get() = getenv("LYNG_CONSOLE_DEBUG_LOG")?.toKString()?.takeIf { it.isNotBlank() }
|
||||
?: "/tmp/lyng_console_flow_debug.log"
|
||||
|
||||
@OptIn(ExperimentalForeignApi::class)
|
||||
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||
// no-op on Native
|
||||
runCatching {
|
||||
val line = buildString {
|
||||
append("[console-flow] ")
|
||||
append(message)
|
||||
append('\n')
|
||||
if (error != null) {
|
||||
append(error.toString())
|
||||
append('\n')
|
||||
}
|
||||
}
|
||||
val file = fopen(flowDebugLogFilePath, "ab") ?: return
|
||||
try {
|
||||
fputs(line, file)
|
||||
} finally {
|
||||
fclose(file)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
package net.sergeych.lyngio.net
|
||||
|
||||
import io.ktor.network.selector.SelectorManager
|
||||
import io.ktor.network.sockets.BoundDatagramSocket
|
||||
import io.ktor.network.sockets.Datagram
|
||||
import io.ktor.network.sockets.InetSocketAddress
|
||||
import io.ktor.network.sockets.ServerSocket
|
||||
import io.ktor.network.sockets.Socket
|
||||
import io.ktor.network.sockets.SocketAddress
|
||||
import io.ktor.network.sockets.aSocket
|
||||
import io.ktor.network.sockets.isClosed
|
||||
import io.ktor.network.sockets.openReadChannel
|
||||
import io.ktor.network.sockets.openWriteChannel
|
||||
import io.ktor.utils.io.ByteReadChannel
|
||||
import io.ktor.utils.io.ByteWriteChannel
|
||||
import io.ktor.utils.io.readAvailable
|
||||
import io.ktor.utils.io.readUTF8Line
|
||||
import io.ktor.utils.io.writeFully
|
||||
import io.ktor.utils.io.writeStringUtf8
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import kotlinx.io.Buffer
|
||||
import kotlinx.io.readByteArray
|
||||
|
||||
internal fun createNativeKtorNetEngine(
|
||||
isSupported: Boolean,
|
||||
isTcpAvailable: Boolean,
|
||||
isTcpServerAvailable: Boolean,
|
||||
isUdpAvailable: Boolean,
|
||||
): LyngNetEngine = NativeKtorNetEngine(
|
||||
isSupported = isSupported,
|
||||
isTcpAvailable = isTcpAvailable,
|
||||
isTcpServerAvailable = isTcpServerAvailable,
|
||||
isUdpAvailable = isUdpAvailable,
|
||||
)
|
||||
|
||||
private class NativeKtorNetEngine(
|
||||
override val isSupported: Boolean,
|
||||
override val isTcpAvailable: Boolean,
|
||||
override val isTcpServerAvailable: Boolean,
|
||||
override val isUdpAvailable: Boolean,
|
||||
) : LyngNetEngine {
|
||||
private val selectorManager: SelectorManager by lazy { SelectorManager(Dispatchers.Default) }
|
||||
|
||||
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
|
||||
val rawAddress = InetSocketAddress(host, port).resolveAddress()
|
||||
?: throw IllegalStateException("Failed to resolve address for $host")
|
||||
return listOf(
|
||||
LyngSocketAddress(
|
||||
host = rawAddress.toIpHostString(),
|
||||
port = port,
|
||||
ipVersion = rawAddress.toLyngIpVersion(),
|
||||
resolved = true,
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
override suspend fun tcpConnect(
|
||||
host: String,
|
||||
port: Int,
|
||||
timeoutMillis: Long?,
|
||||
noDelay: Boolean,
|
||||
): LyngTcpSocket {
|
||||
val connectBlock: suspend () -> Socket = {
|
||||
aSocket(selectorManager).tcp().connect(host, port) {
|
||||
this.noDelay = noDelay
|
||||
}
|
||||
}
|
||||
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
|
||||
return NativeLyngTcpSocket(socket)
|
||||
}
|
||||
|
||||
override suspend fun tcpListen(
|
||||
host: String?,
|
||||
port: Int,
|
||||
backlog: Int,
|
||||
reuseAddress: Boolean,
|
||||
): LyngTcpServer {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
|
||||
backlogSize = backlog
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return NativeLyngTcpServer(server)
|
||||
}
|
||||
|
||||
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
|
||||
val bindHost = host ?: "0.0.0.0"
|
||||
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
|
||||
this.reuseAddress = reuseAddress
|
||||
}
|
||||
return NativeLyngUdpSocket(socket)
|
||||
}
|
||||
}
|
||||
|
||||
private class NativeLyngTcpSocket(
|
||||
private val socket: Socket,
|
||||
) : LyngTcpSocket {
|
||||
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
|
||||
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
|
||||
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun read(maxBytes: Int): ByteArray? {
|
||||
if (!input.awaitContent(1)) return null
|
||||
val buffer = ByteArray(maxBytes)
|
||||
val count = input.readAvailable(buffer, 0, maxBytes)
|
||||
return when {
|
||||
count <= 0 -> null
|
||||
count == maxBytes -> buffer
|
||||
else -> buffer.copyOf(count)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun readLine(): String? = input.readUTF8Line()
|
||||
|
||||
override suspend fun write(data: ByteArray) {
|
||||
output.writeFully(data, 0, data.size)
|
||||
}
|
||||
|
||||
override suspend fun writeUtf8(text: String) {
|
||||
output.writeStringUtf8(text)
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
output.flush()
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class NativeLyngTcpServer(
|
||||
private val server: ServerSocket,
|
||||
) : LyngTcpServer {
|
||||
override fun isOpen(): Boolean = !server.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun accept(): LyngTcpSocket = NativeLyngTcpSocket(server.accept())
|
||||
|
||||
override fun close() {
|
||||
server.close()
|
||||
}
|
||||
}
|
||||
|
||||
private class NativeLyngUdpSocket(
|
||||
private val socket: BoundDatagramSocket,
|
||||
) : LyngUdpSocket {
|
||||
override fun isOpen(): Boolean = !socket.isClosed
|
||||
|
||||
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
|
||||
|
||||
override suspend fun receive(maxBytes: Int): LyngDatagram? {
|
||||
val datagram = try {
|
||||
socket.receive()
|
||||
} catch (e: Throwable) {
|
||||
if (!isOpen()) return null
|
||||
throw e
|
||||
}
|
||||
val bytes = datagram.packet.readByteArray().let {
|
||||
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
|
||||
}
|
||||
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
|
||||
}
|
||||
|
||||
override suspend fun send(data: ByteArray, host: String, port: Int) {
|
||||
val packet = Buffer()
|
||||
packet.write(data)
|
||||
socket.send(Datagram(packet, InetSocketAddress(host, port)))
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
socket.close()
|
||||
}
|
||||
}
|
||||
|
||||
private fun SocketAddress.toLyngSocketAddress(resolved: Boolean): LyngSocketAddress {
|
||||
val inetAddress = this as? InetSocketAddress
|
||||
if (inetAddress != null) {
|
||||
val rawAddress = inetAddress.resolveAddress()
|
||||
val host = rawAddress?.toIpHostString() ?: inetAddress.hostname
|
||||
return LyngSocketAddress(
|
||||
host = host,
|
||||
port = inetAddress.port,
|
||||
ipVersion = rawAddress?.toLyngIpVersion()
|
||||
?: if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = resolved,
|
||||
)
|
||||
}
|
||||
|
||||
val rendered = toString()
|
||||
return LyngSocketAddress(
|
||||
host = rendered,
|
||||
port = 0,
|
||||
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
|
||||
resolved = resolved,
|
||||
)
|
||||
}
|
||||
|
||||
private fun ByteArray.toLyngIpVersion(): LyngIpVersion = if (size == 16) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
|
||||
|
||||
private fun ByteArray.toIpHostString(): String = when (size) {
|
||||
4 -> joinToString(".") { (it.toInt() and 0xff).toString() }
|
||||
16 -> (0 until 8).joinToString(":") { index ->
|
||||
val hi = this[index * 2].toInt() and 0xff
|
||||
val lo = this[index * 2 + 1].toInt() and 0xff
|
||||
((hi shl 8) or lo).toString(16)
|
||||
}
|
||||
else -> error("Unsupported IP address length: $size")
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
package lyng.io.console
|
||||
|
||||
/* Console event kinds used by `ConsoleEvent.type`. */
|
||||
enum ConsoleEventType {
|
||||
UNKNOWN,
|
||||
RESIZE,
|
||||
KEY_DOWN,
|
||||
KEY_UP
|
||||
}
|
||||
|
||||
/* Normalized key codes used by `ConsoleKeyEvent.code`. */
|
||||
enum ConsoleKeyCode {
|
||||
UNKNOWN,
|
||||
CHARACTER,
|
||||
ARROW_UP,
|
||||
ARROW_DOWN,
|
||||
ARROW_LEFT,
|
||||
ARROW_RIGHT,
|
||||
HOME,
|
||||
END,
|
||||
INSERT,
|
||||
DELETE,
|
||||
PAGE_UP,
|
||||
PAGE_DOWN,
|
||||
ESCAPE,
|
||||
ENTER,
|
||||
TAB,
|
||||
BACKSPACE,
|
||||
SPACE
|
||||
}
|
||||
|
||||
/* Detected ANSI terminal capability level. */
|
||||
enum ConsoleAnsiLevel {
|
||||
NONE,
|
||||
BASIC16,
|
||||
ANSI256,
|
||||
TRUECOLOR
|
||||
}
|
||||
|
||||
/* Base class for console events. */
|
||||
extern class ConsoleEvent {
|
||||
/* Event kind for stable matching/switching. */
|
||||
val type: ConsoleEventType
|
||||
}
|
||||
|
||||
/* Terminal resize event. */
|
||||
extern class ConsoleResizeEvent : ConsoleEvent {
|
||||
/* Current terminal width in character cells. */
|
||||
val columns: Int
|
||||
/* Current terminal height in character cells. */
|
||||
val rows: Int
|
||||
}
|
||||
|
||||
/* Keyboard event. */
|
||||
extern class ConsoleKeyEvent : ConsoleEvent {
|
||||
/*
|
||||
Logical key name normalized for app-level handling, for example:
|
||||
"a", "A", "ArrowLeft", "Escape", "Enter".
|
||||
*/
|
||||
val key: String
|
||||
/* Normalized key code enum for robust matching independent of backend specifics. */
|
||||
val code: ConsoleKeyCode
|
||||
/*
|
||||
Optional backend-specific raw identifier (if available).
|
||||
Not guaranteed to be present or stable across platforms.
|
||||
*/
|
||||
val codeName: String?
|
||||
/* True when Ctrl was pressed during the key event. */
|
||||
val ctrl: Bool
|
||||
/* True when Alt/Option was pressed during the key event. */
|
||||
val alt: Bool
|
||||
/* True when Shift was pressed during the key event. */
|
||||
val shift: Bool
|
||||
/* True when Meta/Super/Command was pressed during the key event. */
|
||||
val meta: Bool
|
||||
}
|
||||
|
||||
/* Pull iterator over console events. */
|
||||
extern class ConsoleEventIterator : Iterator<ConsoleEvent> {
|
||||
/* Whether another event is currently available from the stream. */
|
||||
override fun hasNext(): Bool
|
||||
/* Returns next event or throws iteration-finished when exhausted/cancelled. */
|
||||
override fun next(): ConsoleEvent
|
||||
/* Stops this iterator. The underlying console service remains managed by runtime. */
|
||||
override fun cancelIteration(): void
|
||||
}
|
||||
|
||||
/* Endless iterable console event stream. */
|
||||
extern class ConsoleEventStream : Iterable<ConsoleEvent> {
|
||||
/* Creates a fresh event iterator bound to the current console input stream. */
|
||||
override fun iterator(): ConsoleEventIterator
|
||||
}
|
||||
|
||||
/* Terminal geometry in character cells. */
|
||||
extern class ConsoleGeometry {
|
||||
val columns: Int
|
||||
val rows: Int
|
||||
}
|
||||
|
||||
/* Snapshot of console support/capabilities. */
|
||||
extern class ConsoleDetails {
|
||||
/* True when current runtime has console control implementation. */
|
||||
val supported: Bool
|
||||
/* True when output/input are attached to an interactive terminal. */
|
||||
val isTty: Bool
|
||||
/* Detected terminal color capability level. */
|
||||
val ansiLevel: ConsoleAnsiLevel
|
||||
/* Current terminal size if available, otherwise null. */
|
||||
val geometry: ConsoleGeometry?
|
||||
}
|
||||
|
||||
/* Console API singleton object. */
|
||||
extern object Console {
|
||||
/* Returns true when console control API is implemented in this runtime. */
|
||||
fun isSupported(): Bool
|
||||
/* Returns true when process is attached to interactive TTY. */
|
||||
fun isTty(): Bool
|
||||
/* Returns detected color capability level. */
|
||||
fun ansiLevel(): ConsoleAnsiLevel
|
||||
/* Returns current terminal geometry, or null when unavailable. */
|
||||
fun geometry(): ConsoleGeometry?
|
||||
/* Returns combined capability snapshot in one call. */
|
||||
fun details(): ConsoleDetails
|
||||
|
||||
/* Writes raw text to console output buffer (no implicit newline). */
|
||||
fun write(text: String): void
|
||||
/* Flushes pending console output. Call after batched writes. */
|
||||
fun flush(): void
|
||||
|
||||
/* Moves cursor to home position (row 1, column 1). */
|
||||
fun home(): void
|
||||
/* Clears visible screen buffer. Cursor position is backend-dependent after clear. */
|
||||
fun clear(): void
|
||||
/* Moves cursor to 1-based row/column. Values outside viewport are backend-defined. */
|
||||
fun moveTo(row: Int, column: Int): void
|
||||
/* Clears current line content. Cursor stays on the same line. */
|
||||
fun clearLine(): void
|
||||
|
||||
/* Switches terminal into alternate screen buffer (useful for TUIs). */
|
||||
fun enterAltScreen(): void
|
||||
/* Returns from alternate screen buffer to the normal terminal screen. */
|
||||
fun leaveAltScreen(): void
|
||||
/* Shows or hides the cursor. Prefer restoring visibility in finally blocks. */
|
||||
fun setCursorVisible(visible: Bool): void
|
||||
|
||||
/*
|
||||
Returns endless event stream (resize + key events).
|
||||
Typical usage is consuming in a launched loop.
|
||||
*/
|
||||
fun events(): ConsoleEventStream
|
||||
|
||||
/*
|
||||
Enables/disables raw keyboard mode.
|
||||
Returns true when state was actually changed.
|
||||
*/
|
||||
fun setRawMode(enabled: Bool): Bool
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package lyng.io.http
|
||||
|
||||
/*
|
||||
Response/header view that behaves like a map for the first value of each header name.
|
||||
Multi-valued headers are exposed through `getAll`.
|
||||
*/
|
||||
extern class HttpHeaders : Map<String, String> {
|
||||
/* Return the first value for the given header name, or null when absent. */
|
||||
fun get(name: String): String?
|
||||
/* Return all values for the given header name, preserving wire order when available. */
|
||||
fun getAll(name: String): List<String>
|
||||
/* Return distinct header names present in this response. */
|
||||
fun names(): List<String>
|
||||
}
|
||||
|
||||
/* Mutable request descriptor for programmatic HTTP calls. */
|
||||
extern class HttpRequest {
|
||||
/* Request method, e.g. GET, POST, PUT, DELETE. */
|
||||
var method: String
|
||||
/* Absolute URL including scheme. */
|
||||
var url: String
|
||||
/* Simple request headers map. */
|
||||
var headers: Map<String, String>
|
||||
/* Optional UTF-8 request body. */
|
||||
var bodyText: String?
|
||||
/* Optional binary request body. */
|
||||
var bodyBytes: Buffer?
|
||||
/* Optional total request timeout in milliseconds. */
|
||||
var timeoutMillis: Int?
|
||||
}
|
||||
|
||||
/* HTTP response snapshot with cached body accessors. */
|
||||
extern class HttpResponse {
|
||||
/* Numeric status code, e.g. 200, 404, 500. */
|
||||
val status: Int
|
||||
/* Human-readable status text when available. */
|
||||
val statusText: String
|
||||
/* Response headers. */
|
||||
val headers: HttpHeaders
|
||||
/* Decode response body as text. Cached after first call. */
|
||||
fun text(): String
|
||||
/* Return response body as bytes. Cached after first call. */
|
||||
fun bytes(): Buffer
|
||||
}
|
||||
|
||||
/* HTTP/HTTPS client singleton. */
|
||||
extern object Http {
|
||||
/* True when HTTP client support is available on this runtime. */
|
||||
fun isSupported(): Bool
|
||||
|
||||
/* Execute a request described by `HttpRequest`. */
|
||||
fun request(req: HttpRequest): HttpResponse
|
||||
|
||||
/*
|
||||
Convenience GET request.
|
||||
`headers...` accepts `MapEntry` values such as `"Accept" => "text/plain"`
|
||||
and 2-item lists such as `["Accept", "text/plain"]`.
|
||||
*/
|
||||
fun get(url: String, headers...): HttpResponse
|
||||
|
||||
/*
|
||||
Convenience POST request with UTF-8 body text.
|
||||
`headers...` follows the same rules as `get`.
|
||||
*/
|
||||
fun post(url: String, bodyText: String = "", contentType: String? = null, headers...): HttpResponse
|
||||
|
||||
/*
|
||||
Convenience POST request with binary body.
|
||||
`headers...` follows the same rules as `get`.
|
||||
*/
|
||||
fun postBytes(url: String, body: Buffer, contentType: String? = null, headers...): HttpResponse
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
package lyng.io.net
|
||||
|
||||
/* Address family for resolved or bound endpoints. */
|
||||
enum IpVersion {
|
||||
IPV4,
|
||||
IPV6
|
||||
}
|
||||
|
||||
/* Concrete socket endpoint. */
|
||||
extern class SocketAddress {
|
||||
/* Numeric or host-form address string. */
|
||||
val host: String
|
||||
/* Transport port number. */
|
||||
val port: Int
|
||||
/* Address family. */
|
||||
val ipVersion: IpVersion
|
||||
/* True when obtained from DNS resolution rather than raw bind input. */
|
||||
val resolved: Bool
|
||||
/* Stable printable form such as `127.0.0.1:4040` or `[::1]:4040`. */
|
||||
override fun toString(): String
|
||||
}
|
||||
|
||||
/* Datagram payload paired with sender/peer address. */
|
||||
extern class Datagram {
|
||||
val data: Buffer
|
||||
val address: SocketAddress
|
||||
}
|
||||
|
||||
/* Connected TCP socket. */
|
||||
extern class TcpSocket {
|
||||
/* True while the socket remains open. */
|
||||
fun isOpen(): Bool
|
||||
/* Local bound address after connect/bind. */
|
||||
fun localAddress(): SocketAddress
|
||||
/* Connected peer address. */
|
||||
fun remoteAddress(): SocketAddress
|
||||
/* Read up to `maxBytes`; returns null on clean EOF before any data. */
|
||||
fun read(maxBytes: Int = 65536): Buffer?
|
||||
/* Read one UTF-8 line without trailing newline; null on clean EOF. */
|
||||
fun readLine(): String?
|
||||
/* Write all bytes from the buffer. */
|
||||
fun write(data: Buffer): void
|
||||
/* Write UTF-8 encoded text. */
|
||||
fun writeUtf8(text: String): void
|
||||
/* Flush buffered output if needed by the backend. */
|
||||
fun flush(): void
|
||||
/* Close the socket. */
|
||||
fun close(): void
|
||||
}
|
||||
|
||||
/* Listening TCP server socket. */
|
||||
extern class TcpServer {
|
||||
/* True while the listening socket remains open. */
|
||||
fun isOpen(): Bool
|
||||
/* Actual local bind address. */
|
||||
fun localAddress(): SocketAddress
|
||||
/* Accept next incoming client connection. */
|
||||
fun accept(): TcpSocket
|
||||
/* Close the listening socket. */
|
||||
fun close(): void
|
||||
}
|
||||
|
||||
/* Bound UDP socket. */
|
||||
extern class UdpSocket {
|
||||
/* True while the socket remains open. */
|
||||
fun isOpen(): Bool
|
||||
/* Actual local bind address. */
|
||||
fun localAddress(): SocketAddress
|
||||
/* Receive one datagram up to `maxBytes`, or null on clean shutdown. */
|
||||
fun receive(maxBytes: Int = 65536): Datagram?
|
||||
/* Send one datagram to the provided host and port. */
|
||||
fun send(data: Buffer, host: String, port: Int): void
|
||||
/* Close the socket. */
|
||||
fun close(): void
|
||||
}
|
||||
|
||||
/* Raw transport networking singleton. */
|
||||
extern object Net {
|
||||
/* True when at least one transport feature is implemented on this runtime. */
|
||||
fun isSupported(): Bool
|
||||
/* True when outbound TCP client sockets are available. */
|
||||
fun isTcpAvailable(): Bool
|
||||
/* True when listening TCP server sockets are available. */
|
||||
fun isTcpServerAvailable(): Bool
|
||||
/* True when UDP datagram sockets are available. */
|
||||
fun isUdpAvailable(): Bool
|
||||
|
||||
/* Resolve host name and port into concrete addresses. */
|
||||
fun resolve(host: String, port: Int): List<SocketAddress>
|
||||
|
||||
/* Connect outbound TCP socket. */
|
||||
fun tcpConnect(
|
||||
host: String,
|
||||
port: Int,
|
||||
timeoutMillis: Int? = null,
|
||||
noDelay: Bool = true
|
||||
): TcpSocket
|
||||
|
||||
/* Start listening TCP server socket. */
|
||||
fun tcpListen(
|
||||
port: Int,
|
||||
host: String? = null,
|
||||
backlog: Int = 128,
|
||||
reuseAddress: Bool = true
|
||||
): TcpServer
|
||||
|
||||
/* Bind UDP socket, using an ephemeral port by default. */
|
||||
fun udpBind(
|
||||
port: Int = 0,
|
||||
host: String? = null,
|
||||
reuseAddress: Bool = true
|
||||
): UdpSocket
|
||||
}
|
||||
Loaded 100 of 181 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user