gloo 7.0.4 → 7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f84c9907a97353612993852efc46b6880b119c962b785da1c43326f1d0710b3
-  data.tar.gz: 6582c120e0b04e9daaa3be9d70002d407f778b045fa668f87ca20fae68b22218
+  metadata.gz: d25bb60fb25bb1b42e44eeac62b0ec3bae86a9f3770c696caf4ab39b7f1c9784
+  data.tar.gz: 260731b8d5f1cd1c6f3718be0d26f17d39139795e7e5c13ff8908a4fc3f1c453
 SHA512:
-  metadata.gz: 5ad11f0ed9bec1122fc796920029ee5b1bdea8dee0e3aecdedefd85241de70ff1f52e8fb893726d6fd135a0e86588aac44ab6598d2a3b6f071f61c2411281adc
-  data.tar.gz: ec26f94681a480a42bf9cf21ca7668de7896eba9937a731d501c1ca2a5998fe12dc08b26e9452c9aeafbee59f2eb3e21b1599af8e3211f8e5baa593d232a3146
+  metadata.gz: 3729efcd7dcfa5964a408fb28750bd2ac7caea3af323b1ea8c8b75503446f51805db7f20b05bfd705a9ac020bd06fe6fba5135013137e937f7dd6f499e134f40
+  data.tar.gz: d69918fdaf8ab491ac5bc21cd7a838048ef4eaf2299d8a867eea017b14c0f5ca3a314e7106e6fc0bf00fad8e949550efaae897121d8ae11de4d964a1a0231218

data/README.md

@@ -47,7 +47,8 @@ Read in order for a guided tour of the language, top to bottom, or jump straight
 8. [Operators](docs/operators.md) — math and comparison operators
 9. [Iterators](docs/iterators.md) — each, repeat
 10. [Plugins](docs/plugins.md) — core libraries and user extensions
-11. [A Trivial Web App](docs/web_app.md) — a two-page "Hello World" built with the `gloo-web` core library
+11. [Testing](docs/testing.md) — writing and running gloo tests with `gloo-test`
+12. [A Trivial Web App](docs/web_app.md) — a two-page "Hello World" built with the `gloo-web` core library
 
 Working on gloo itself? See [Development](docs/development.md) — source layout, running the tests, and conventions.
 

data/docs/application.md

@@ -17,6 +17,7 @@ Gloo keeps its configuration, projects, and logs under a per-user home directory
 - `gloo.gloo_config` — the configuration directory (see Configuration, below)
 - `gloo.gloo_projects` — the projects directory (same as `gloo.app` when an app is running)
 - `gloo.gloo_log` — the logging directory (see Logging, below)
+- `gloo.gloo_tmp` — a folder for temporary files, such as scratch files a script or test writes and then deletes. It's `tmp` under the gloo home directory unless `tmp_path` in `gloo.yml` says otherwise (see Configuration, below), and it's created if it isn't there. Use it instead of `/tmp`, which doesn't exist on Windows.
 
 ```
 > show gloo.gloo_home
@@ -70,6 +71,11 @@ When specifying a file there are a couple ways to reference the gloo file to ope
              - Run the script in the file parameter and then quit.
              - If a file is provided as a parameter this option does not need to be specified.
 --test       - Run in Test mode
+             - Runs the *.test.gloo files in the folders and files given
+               (the current folder if none), using the gloo-test library.
+             - Exits with status 1 if any test failed, or errors or warnings
+               were logged that no test expected; 0 otherwise.
+             - See Testing.
 --version    - Show application version
 --help       - Show the help screen
 ```
@@ -90,6 +96,12 @@ gloo:
   #
   project_path: /Users/my_user/gloo/projects
 
+  #
+  # Folder for temporary files, such as scratch files written by
+  # tests. Scripts get it with $.gloo_tmp.
+  #
+  tmp_path: /Users/my_user/gloo/tmp
+
   #
   # Run this script when starting up gloo.
   # (Only if a script file is not specified.)
@@ -146,9 +158,11 @@ Gloo writes to the `gloo.log` and `error.log` files as well as to the console.
 
 Debug messages are written to the log only, but other messages are also written to the console unless the application is running in quiet mode.
 
+On the console, errors and warnings go to stderr, while a script's own output (`show`) goes to stdout. So the two can be redirected separately: `gloo my_script.gloo 2>/dev/null` shows just the script's output.
+
 Only error and warning level messages are written to the error log.
 
-In test mode (`--test`), errors and warnings go to the log files only, not the console, so the test output is just the test results. An error a test expects (or one from a test file that deliberately contains a problem) is still in `error.log`.
+In test mode (`--test`), errors and warnings go to the log files only, not the console, so the test output is just the test results. An error a test expects (or one from a test file that deliberately contains a problem) is still in `error.log`. The summary at the end of a test run says how many errors and warnings were logged, and by which tests, leaving out those a test expects (`expect_errors`). See Testing.
 
 The application logs folder is in the gloo folder. When gloo is run, the log files will be created if they do not exist. To trim the logs, just delete those log files.
 
@@ -199,4 +213,4 @@ help> quit
 
 ### Narrative Docs in the Shell
 
-This page and its ten siblings (`docs/*.md` in the interpreter's source) are the same files shown by `help> doc {name}` — there's no separate doc server or web mode. A `gloo --doc` local web server was considered and put off in favor of this: one system, no separate build/serve step.
+This page and the others in `docs/` (in the interpreter's source) are the same files shown by `help> doc {name}` — there's no separate doc server or web mode. A `gloo --doc` local web server was considered and put off in favor of this: one system, no separate build/serve step.

data/docs/development.md

@@ -54,7 +54,7 @@ Integration tests written in gloo itself, using the `[test]` object from the `gl
 gem install gloo-test gloo-yaml gloo-md
 ```
 
-Each `*.test.gloo` file holds `[test]` objects whose `on_test` script uses `assert` and `refute`:
+Each `*.test.gloo` file holds `[test]` objects whose `on_test` script uses `assert` and `refute`. How to write them (assertions, shuffled order, `expect_errors`, `expect_fail`, scratch files and fixtures) is in Testing; this section covers only what's particular to the interpreter's own suite. A test looks like this:
 
 ```gloo
 tests [can] :

data/docs/iterators.md

@@ -9,6 +9,7 @@
 - Each Line
 - Each Word
 - Repeat
+- Ending a Loop Early
 
 ## Each
 
@@ -328,3 +329,26 @@ repeat [can] :
 ```
 
 See also: Object Base.
+
+## Ending a Loop Early
+
+`break` in a loop's `do` script ends the whole loop, not just that pass. This works for `repeat` and every kind of `each`. The script that ran the loop carries on with its next line:
+
+```gloo
+early [can] :
+  on_load [script] :
+    tell early.r to run
+    show 'after the loop'
+  r [repeat] :
+    times [int] : 5
+    index [int] :
+    do [script] :
+      if early.r.index = 2 then break
+      show early.r.index
+```
+
+This shows `0`, `1`, then `after the loop`.
+
+`break` ends the script it's written in. So in nested loops, a `break` in the inner loop's `do` ends only the inner loop, and a `break` in a script the `do` script runs (with `run`, or a function it invokes) ends only that script, not the loop. An `each` with `group_by` still runs `on_group_end` for the group that was open when the loop ended.
+
+See also: Break.

data/docs/language_objects.md

@@ -4,6 +4,8 @@
 
 - Object Naming
 - Nested Container Shorthand
+- Documenting an Object
+- Where an Object Came From
 - Keywords
 - Literals
 - Value Conversion
@@ -113,6 +115,38 @@ deleted, its doc comment goes with it (see Verbs, Load & Save).
 `list_docs` setting (off by default) — see `list` and `settings` in the
 in-app help.
 
+## Where an Object Came From
+
+Every object can say which file it was loaded from: `check {obj} for
+source_file` puts the file's full path in `it`, and `check {obj} for
+source_dir` puts that file's folder (with no trailing slash). This lets a
+script reach files stored next to it without a hard-coded path. For
+example, a test can load a fixture that sits beside its own file:
+
+```gloo
+tests.my_area [can] :
+  where [string] :
+  fixture [string] : /fixtures/sample.gloo
+
+  loads_its_fixture [test] :
+    on_test [script] :
+      check ^^ for source_dir
+      put it into ^^.where
+      load ( ^^.where ^^.fixture )
+```
+
+The answer comes from the nearest object, going up from the one asked,
+that a loaded file declares. So a nested object answers with its file,
+even when its root container (like `tests` above) is declared in many
+files. An object created at run time inside a loaded one answers with
+that one's file. When several files declare the same object (a namespace
+container), the first file loaded answers.
+
+An object that didn't come from a file (created at run time, or
+unloaded) answers blank (`''`); that isn't an error. On a `[file]`
+object, `source_file` is the `.gloo` file that declared it, not the path
+it holds.
+
 ## Keywords
 
 Gloo doesn't reserve words the way many languages do. A verb keyword like `put` or an object type name like `string` can also be used as an object name — there's no parser conflict, because verbs are only looked up as the first word of a statement, and object type names are only looked up where a type is expected (inside the `[ ]` on a declaration). Everywhere else, the word is just a pathname segment (see Object Naming, above).

data/docs/language_syntax.md

@@ -3,6 +3,7 @@
 **Contents**
 
 - Color
+- Computed Arguments
 - Errors
 - Events
 - Function Calls
@@ -43,6 +44,28 @@ colors [can] :
 
 See also: Show.
 
+## Computed Arguments
+
+Some verbs take literal text rather than an object or an expression: a file name, a path, a name. Each of these can instead be an expression in parentheses. Gloo works out the expression and uses its value as the text:
+
+```
+load ( $.gloo_tmp '/scratch.gloo' )
+load lib ( lib_name )
+save my_obj to ( $.gloo_tmp '/my_obj' )
+context ( 'app.' section )
+exists? object ( type_name )
+```
+
+This works for `load` (a file, `ext` or `lib`), `save … to`, `context` and `exists?`. Anything not in parentheses is still taken literally, so `load common/app/*` still loads those files. A computed file name goes through the same lookup as a literal one, so wildcards, the `.gloo` extension and project-relative names work the same way.
+
+The `+` is optional when joining text, so `( $.gloo_tmp '/scratch.gloo' )` and `( $.gloo_tmp + '/scratch.gloo' )` are the same. A `[file]` or `[string]` object holding a path works too: `load ( my.file_obj )`.
+
+If the expression can't be worked out (for example, an object it names doesn't exist), that's reported as an error and the verb doesn't run.
+
+For anything else, `run ~>` works out a whole command and runs it: `run ~> 'load ' $.gloo_tmp '/x.gloo'`. Prefer the parentheses where they're available; a command built this way breaks if a path has spaces in it.
+
+See also: Load, Save, Context, Exists.
+
 ## Errors and Warnings
 
 Gloo makes a best guess and keeps going when it can, but it never does so silently: every problem is reported, in one of these ways.
@@ -52,7 +75,7 @@ Gloo makes a best guess and keeps going when it can, but it never does so silent
 - **Warning** — the command was done, but probably not the way it was meant: a value that isn't really of its type, used as a best guess (`'x' is not an integer; using 0.`), or indentation that doesn't line up. A warning is only logged; it isn't an error.
 - **Just a result** — a question whose answer is "no" is not an error at all: `exists?`, `contains?`, `substring?`, and `index_of` (which gives -1) answer in `it`.
 
-Errors are logged with where they happened in front of the message: the file and line while a file is loading (`app.gloo:12: Unknown type 'strng'; using untyped.`), or the script and its line (`app.on_load, line 3: Object 'app.nme' was not found.`). "Not found" errors always read the same way: `Object 'x' was not found.`, `File 'x' was not found.`, `Folder 'x' was not found.`, `Verb 'x' was not found.`
+Errors and warnings are logged with where they happened in front of the message: the file and line while a file is loading (`app.gloo:12: Unknown type 'strng'; using untyped.`), even when a script started the load; otherwise the script and its line (`app.on_load, line 3: Object 'app.nme' was not found.`). On the console both go to stderr, apart from a script's own output. "Not found" errors always read the same way: `Object 'x' was not found.`, `File 'x' was not found.`, `Folder 'x' was not found.`, `Verb 'x' was not found.`
 
 What happens after an error:
 
@@ -254,6 +277,7 @@ gloo.gloo_home        # Get the gloo home directory
 gloo.gloo_config      # Get the gloo configuration directory
 gloo.gloo_projects    # Get the gloo projects directory
 gloo.gloo_log         # Get the gloo logging directory
+gloo.gloo_tmp         # Get the gloo tmp directory, for temporary files
 
 SCREEN
 gloo.screen_lines     # Get the number of lines on screen.
@@ -308,6 +332,7 @@ See also: Pathname.
 
 - **A question** (`check x for exists?`, `contains?`, `starts_with?`, …) puts its answer in `it`.
 - **A command or message that works out a value** puts that value in `it` (`eval`, `put`, `show 3 + 4`) — even if it also stores it somewhere, in the object's own value (`trim`, `sub`, `format_for_html`) or in a child (`run` on an `erb`, `http_get` or `system` object also sets its `result`).
+- **A message that puts its result into a destination you name** puts its status in `it`: `true` when it worked, `false` when it didn't. With no destination, the result itself goes in `it`. So `tell f to read ( text )` puts the file's contents in `text` and `true` in `it`, while `tell f to read` puts the contents in `it`. The same goes for json `parse ( dst )` and string `split_list ( delim dst )`.
 - **A pure action** — `list`, a bare `show`, deleting, opening a file — leaves `it` alone, so a value in `it` survives it. Running a script or a loop doesn't set `it` either, though the commands inside it do.
 - **When something goes wrong** in a question or a command that would set `it`, the problem is reported and `it` is `false`. The same goes for a message that never gets to run — the object doesn't exist, or doesn't take that message — including `run` itself: `it` is `false`, so no stale value from an earlier line is left behind.
 

data/docs/objects.md

@@ -4,7 +4,7 @@ Everything in gloo is an object. Strings, numbers, containers, scripts, function
 
 Gloo ships with a large set of built-in object types, and core libraries and extensions can add more. This page doesn't try to cover them all — it walks through three common ones to get a feel for how objects work. For the complete list of object types, and every message each one supports, use the in-app help: enter `help` (or `?`), then `objects` to list them all, or `object {name}` for detail on one (see Application, Help).
 
-An object's **type declares which messages it can receive** — `up` and `trim` for a `string`, `inc` for an `integer`, `run` for a `script`. An object doesn't have to have a type: with none it is `untyped` (short `any`), declared with a bare colon (`slot :`), with `[any]`, or by `create` with no `as`. An untyped object still takes the messages every object understands (`blank?`, `contains?`, `responds_to?`, `doc`, `reload`, `unload`) — just not the type-specific ones. Of those, `blank?` asks about the object's simple value only, and `contains?` asks whether it has children: a container with children but no value of its own is blank, and contains. Untyped is the right choice when you only need to hold, compare, or show a value: a generic result slot, a config value passed straight through, or a field whose kind of value changes over its life.
+An object's **type declares which messages it can receive** — `up` and `trim` for a `string`, `inc` for an `integer`, `run` for a `script`. An object doesn't have to have a type: with none it is `untyped` (short `any`), declared with a bare colon (`slot :`), with `[any]`, or by `create` with no `as`. An untyped object still takes the messages every object understands (`blank?`, `contains?`, `responds_to?`, `doc`, `source_dir`, `source_file`, `reload`, `unload`) — just not the type-specific ones. Of those, `blank?` asks about the object's simple value only, and `contains?` asks whether it has children: a container with children but no value of its own is blank, and contains. Untyped is the right choice when you only need to hold, compare, or show a value: a generic result slot, a config value passed straight through, or a field whose kind of value changes over its life.
 
 **Contents**
 

data/docs/plugins.md

@@ -29,6 +29,12 @@ settings [can] :
 
 The loader runs these top-of-file `load lib` / `load ext` lines before it builds the object tree, so declarations below them can use the library's types. Only `load lib` and `load ext` are recognized this way, and only above the first object — a `load lib` in a script still runs when that script runs, as before.
 
+When working on a core library, `load lib` loads the installed gem, not the copy you're editing, so its tests quietly test the installed version. To test the edited source, run from the library's folder with `RUBYLIB` pointing at its `lib/`:
+
+```
+RUBYLIB="$(pwd)/lib" gloo --test test/
+```
+
 ### Available Core Libraries
 
 - **CLI** — Use the `gloo-cli` gem when building CLI applications.
@@ -60,7 +66,7 @@ The loader runs these top-of-file `load lib` / `load ext` lines before it builds
     > load lib md
     help> object markdown
     ```
-- **Test** — Use the `gloo-test` gem to manually include. See Test Runner for notes about the gloo test runner.
+- **Test** — Use the `gloo-test` gem to write and run gloo tests. `gloo --test` loads it for you; see Testing for how to write and run tests.
     - Library Objects: Test
     - Library Verbs: Assert, Refute
     - See also: Eval, It
@@ -348,7 +354,7 @@ class Stats < Gloo::Core::Obj
 end
 ```
 
-`self.messages` should call `super` and append to it — the base `Gloo::Core::Obj` already contributes messages every object receives (`reload`, `unload`, `blank?`, `contains?`, `responds_to?`).
+`self.messages` should call `super` and append to it — the base `Gloo::Core::Obj` already contributes messages every object receives (`save`, `reload`, `unload`, `blank?`, `contains?`, `responds_to?`, `doc`, `source_dir`, `source_file`).
 
 Used from gloo, once loaded:
 
@@ -366,7 +372,7 @@ Register it from `stats_ext.rb` with `callback.register_obj( Stats )`.
 
 ### Custom `each` iterators
 
-An extension's object can also plug into the built-in `each` verb by providing its own iterator. `extensions/git/src/each_repo.rb` shows the shape: a plain Ruby class (not a `Gloo::Core::Obj`) with `self.use_for?( iterator_obj )` — which returns `true` when the `each` loop's iterator object looks like a match (here, when it has a `repo` child) — and a `run` method that walks whatever it's iterating over, setting the loop's child value and calling `@iterator_obj.run_do` for each item. See the git extension for the full pattern; this hook only makes sense for extensions that also register a matching object type (here, `git_repo`).
+An extension's object can also plug into the built-in `each` verb by providing its own iterator. `extensions/git/src/each_repo.rb` shows the shape: a plain Ruby class (not a `Gloo::Core::Obj`) with `self.use_for?( iterator_obj )` — which returns `true` when the `each` loop's iterator object looks like a match (here, when it has a `repo` child) — and a `run` method that walks whatever it's iterating over, setting the loop's child value and calling `@iterator_obj.run_do` for each item. `run_do` returns true when a `break` in the `do` script ended it, so stop the walk then: `break if @iterator_obj.run_do`. See the git extension for the full pattern; this hook only makes sense for extensions that also register a matching object type (here, `git_repo`).
 
 ### Documenting the extension
 
@@ -374,7 +380,7 @@ Add `self.doc_data` to every verb/object class (see the `beep` and `stats` examp
 
 ### Testing an extension
 
-Add a Ruby unit test per verb/object class under `test/` (the same conventions as the interpreter's own tests, see Development, Tests — inherit from the project's `GlooTest`/`BaseEngineTest` base), and add a `*.test.gloo` integration test that loads the extension and exercises it end to end, e.g. `extensions/beep/test/beep.test.gloo`:
+Add a Ruby unit test per verb/object class under `test/` (the same conventions as the interpreter's own tests, see Development, Tests — inherit from the project's `GlooTest`/`BaseEngineTest` base), and add a `*.test.gloo` integration test that loads the extension and exercises it end to end (see Testing for how to write and run gloo tests), e.g. `extensions/beep/test/beep.test.gloo`:
 
 ```gloo
 tests [can] :

data/docs/testing.md

@@ -0,0 +1,206 @@
+# Testing
+
+How to write and run tests for gloo code: an app, an extension or a core library. Tests are written in gloo itself, in `*.test.gloo` files, using the `[test]` object and the `assert` and `refute` verbs from the `gloo-test` core library. This page is about those gloo tests. Ruby unit tests for an extension's Ruby code are covered in Plugins, Testing an Extension; for the interpreter's own tests, see Development, Tests.
+
+**Contents**
+
+- Running Tests
+- Writing a Test
+- Assertions
+- Test Order and Setup
+- Errors and Warnings
+- Tests Meant to Fail
+- Files in Tests
+
+## Running Tests
+
+Install the `gloo-test` gem, then run gloo in test mode with the tests to run:
+
+```
+gem install gloo-test
+gloo --test path/to/tests/
+```
+
+`--test` loads the `gloo-test` library itself, so a test file doesn't need `load lib test`. Give any mix of folders and single files. In a folder, every `*.test.gloo` file is run, including those in subfolders. With no path, gloo looks in the current folder.
+
+While the tests run, gloo shows a `.` for each test that passes and an `x` for each one that fails. Then it lists the failures, each with the test's path, its description and the message of the assertion that failed, and ends with a summary:
+
+```
+x.....
+
+*** Failures (1) ***
+
+tests.math.wrong_on_purpose -> A failing test, to see the output.
+   expected 2 + 2 to be 5
+
+Tests: 6 • Passed: 5 •  Failed: 1
+  Assertions: 6 • Files: 2
+Tests finished in 0.01 seconds
+```
+
+In test mode, errors and warnings go to the log files, not the console, so the output is just the test results (see Application, Logging). The summary says when any were logged; see Errors and Warnings, below.
+
+When the run is over, gloo exits with status 0 if it passed, and 1 if any test failed or the summary reports errors or warnings that no test expected. A missing test file or folder counts too. So a script or CI job can tell a good run from a bad one:
+
+```
+gloo --test test/ && echo "all good"
+```
+
+## Writing a Test
+
+A test file holds one root container with `[test]` objects inside it. By convention, the root is `tests`, and each file adds its own area under it with nested container shorthand (see Language, Objects), so many test files can share the `tests` root:
+
+```gloo
+tests.math [can] :
+
+  total [int] : 0
+
+  adds_up [test] :
+    description [string] : Adding two numbers.
+    on_test [script] :
+      eval 2 + 2
+      put it into ^^.total
+      eval ^^.total = 4
+      assert "expected 2 + 2 to be 4"
+```
+
+A `[test]` has two children:
+
+- `description` — what the test checks. It's shown with the test's path when the test fails.
+- `on_test` — the script that does the work and makes the assertions.
+
+Inside `on_test`, `^` is the test and `^^` is the container that holds it, so `^^.total` is the `total` object beside the test. Objects a test works with usually sit in the container, next to the tests.
+
+## Assertions
+
+`assert` and `refute` look at `it`. `assert` passes if `it` is true; `refute` passes if `it` is false. Each takes an optional message, which is shown if it fails, so write it as what was expected:
+
+```gloo
+check ^^.name for blank?
+refute "expected the name to be set"
+
+eval ^^.count > 0
+assert "expected at least one item"
+```
+
+`expect` is another name for `assert`, and `expect_not` for `refute`.
+
+So a test usually puts the thing it's checking into `it` first: with `eval` for a comparison, `check` for a question (`blank?`, `contains?`, `exists?`), or a message or verb that sets `it` (see Language, Syntax, It). A test can have any number of assertions, and it fails if any one of them fails.
+
+## Test Order and Setup
+
+Tests run in a random order: the files are shuffled, and so are the tests within each file. A test mustn't depend on another test having run first. Each one sets up what it needs and cleans up after itself.
+
+Between files, the heap is emptied: objects a file loads are gone before the next file runs. Within a file, the tests share the file's objects, so a test that uses one should set it at the start rather than rely on its declared value. For example, `put false into ^^.err_fired` before the step that should set it.
+
+Setup that's the same for every test in a file, and that no test changes, can go in an `on_load` script in the file's container. It runs when the file loads, before any of its tests:
+
+```gloo
+tests.files [can] :
+
+  scratch [file] :
+
+  # Runs when this file loads, before any test.
+  on_load [script] :
+    put $.gloo_tmp '/my_scratch.gloo' into ^.scratch
+```
+
+## Errors and Warnings
+
+The run keeps track of the errors and warnings logged by each test. If any were logged, the summary gets an extra line naming the tests that logged them:
+
+```
+Tests: 4 • Passed: 4 •  Failed: 0
+  Assertions: 4 • Files: 1
+  1 error logged during the run; see ~/gloo/logs/error.log
+    tests.files.missing_file_is_an_error (1 error)
+Tests finished in 0.0 seconds
+```
+
+Problems logged while a test file loads, outside any test, are counted too, as `(outside tests: …)`. A clean run has no such line. Treat one as a problem even when every test passed: something went wrong that no assertion caught.
+
+A test that triggers an error or a warning on purpose (to check an `on_error` handler, or that bad input is reported) sets `expect_errors` to true. What it logs is then left out of the summary:
+
+```gloo
+tests.files [can] :
+
+  err_fired [bool] : false
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  missing_file_is_an_error [test] :
+    description [string] : Loading a file that isn't there fires on_error.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      load no_such_file_xyz
+      eval ^^.err_fired = true
+      assert "expected on_error to fire"
+```
+
+## Tests Meant to Fail
+
+A test that's meant to fail, such as one that shows an assertion really does fail when it should, sets `expect_fail` to true. It then passes if at least one of its assertions fails, and fails if none does:
+
+```gloo
+  false_fails_an_assert [test] :
+    description [string] : assert fails when it is false.
+    expect_fail [bool] : true
+    on_test [script] :
+      eval 1 = 2
+      assert "this one is meant to fail"
+```
+
+`expect_fail` can't tell which assertion failed, or why, so a test can fail for the wrong reason and still pass. Keep a test like this to the one thing it checks. That's good practice for every test, but it matters most here.
+
+## Files in Tests
+
+**Scratch files.** A test that needs a file it writes and then deletes should put it in the gloo tmp folder, `$.gloo_tmp`, rather than `/tmp`, which doesn't exist on Windows (see Application, The Gloo Home Directory). Set the path once in `on_load`, as in Test Order and Setup, above. To load the file, put the path in parentheses so it's worked out rather than taken literally (see Language, Syntax, Computed Arguments). Unload what was loaded and delete the file at the end of the test:
+
+```gloo
+      tell ^^.scratch to write ( ^^.source )
+      load ( ^^.scratch )
+      # ... assertions ...
+      tell demo to unload
+      tell ^^.scratch to delete
+```
+
+**Fixtures.** A file the tests read but never change can be kept next to the test file, for example in a `fixtures` folder. Name it something other than `*.test.gloo`, so it isn't run as a test. `check ^^ for source_dir` gives the folder of the test file (see Language, Objects, Where an Object Came From):
+
+```gloo
+tests.files [can] :
+
+  where [string] :
+  fixture [string] : /fixtures/sample.gloo
+
+  loads_its_fixture [test] :
+    description [string] : A fixture next to this file can be loaded.
+    on_test [script] :
+      check ^^ for source_dir
+      put it into ^^.where
+      load ( ^^.where ^^.fixture )
+      eval sample.name = 'from the fixture'
+      assert "expected the fixture to load"
+      tell sample to unload
+```
+
+**Broken source on purpose.** To test how gloo handles a mistake in a file, such as a missing `]` or a declaration with no name, don't put the mistake in the test file itself. It would be reported while the file loads, outside any test. Instead, keep the broken source in a `[text]` object, write it to a scratch file inside the test, and load it there. The problem then belongs to that test, which sets `expect_errors`:
+
+```gloo
+  broken_src [text] : BEGIN
+broken_demo [can] :
+  count [int : 3
+END
+
+  broken_source_still_loads [test] :
+    description [string] : A type missing its ] is still read as that type.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.scratch to write ( ^^.broken_src )
+      load ( ^^.scratch )
+      eval broken_demo.count = 3
+      assert "expected the value 3"
+      tell broken_demo to unload
+      tell ^^.scratch to delete
+```

data/docs/verbs.md

@@ -58,6 +58,13 @@ tell {path.to.object} to {message}
 > show it
 ```
 
+`source_dir` and `source_file` are two more: they put the folder, or the full path, of the file the object was loaded from in `it` — blank if it didn't come from a file (see Language, Objects — Where an Object Came From).
+
+```gloo
+> check my.obj for source_dir
+> show it
+```
+
 ## Put
 
 `put` evaluates an expression and stores the result in an object.

data/lib/VERSION

@@ -1 +1 @@
-7.0.4
+7.1.1

data/lib/VERSION_NOTES

@@ -1,3 +1,20 @@
+7.1.1 - 2026.10.26
+ - Fixes issues with the value in it after a failed command.
+ - Warnings go to stderr, like errors.
+ - Break in a loop's do script now ends the whole loop.
+ - Cipher doc and test updated.
+
+
+7.1 - 2026.10.23
+ - Loading an empty gloo file is now allowed and only gives a warning.
+ - Adds configuration setting for tmp directory.
+ - load (file, lib, ext), save … to, context and exists? accept ( expression ) in place of a literal name or path. For example, load ( $.gloo_tmp '/x.gloo' ).
+ - save … to with a blank path reports the missing-path error.
+ - Updates for more consistent results in `it`.
+ - Get source file path and name for object.
+ - Adds doc for gloo tests.
+
+
 7.0.4 - 2026.10.19
  - Documentation update.
 
@@ -169,7 +186,7 @@
 
 
 5.1.0 - 2026.02.15
- - Fixes issue with int * dec 
+ - Fixes issue with int * dec
  - Some code cleanup
 
 
@@ -396,4 +413,3 @@ adds tag helper for apple touch icon
 
 2.0 - 2023.05.22
  - Version 2 merges gloo-lang back into a single gloo gem.
-

data/lib/gloo/app/engine.rb

@@ -154,21 +154,31 @@ module Gloo
         @args.files.each { |f| @persist_man.load( f ) }
       end
 
-      # 
+      #
       # Run in gloo unit test mode.
+      # Then quit, with exit status 1 if the run failed (see run_tests),
+      # so a calling script or CI job can tell.
       #
       def run_test
         @log.debug 'Running in Test mode…'
-
-        begin
-          @lib_manager.load_lib TEST_LIB_NAME
-          TestRunner.new( self, @args.files ).run
-        rescue StandardError, ScriptError => ex
-          handle_exception ex
-        end
-
+        passed = run_tests
         @log.debug 'Tests complete.'
         quit
+        exit( 1 ) unless passed
+      end
+
+      #
+      # Load gloo-test and run the tests given on the command line.
+      # True unless the run reports that it failed, or something went
+      # wrong running it. An older gloo-test whose run doesn't report
+      # counts as passed, as it always has.
+      #
+      def run_tests
+        @lib_manager.load_lib TEST_LIB_NAME
+        return TestRunner.new( self, @args.files ).run != false
+      rescue StandardError, ScriptError => ex
+        handle_exception ex
+        return false
       end
 
       #

data/lib/gloo/app/log.rb

@@ -168,13 +168,13 @@ module Gloo
 
       #
       # Write a warning message to the log.
-      # Also write to the console unless quiet.
+      # Also write to the console (on stderr, like errors) unless quiet.
       #
       def warn( msg )
         @warning_count += 1
         @logger.warn msg
         @error.warn msg
-        puts @theme.warn( msg ) if errors_to_console?
+        $stderr.puts @theme.warn( msg ) if errors_to_console?
       end
 
       #