gloo 7.1 → 7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 211368f27a7bbea86aed449d545c28f05a62857e92e8a3942394261a336e597b
-  data.tar.gz: 98ea31342225ac55d1ae499727fe2e71bf1679a8c4f1523651e57ac50829a714
+  metadata.gz: d25bb60fb25bb1b42e44eeac62b0ec3bae86a9f3770c696caf4ab39b7f1c9784
+  data.tar.gz: 260731b8d5f1cd1c6f3718be0d26f17d39139795e7e5c13ff8908a4fc3f1c453
 SHA512:
-  metadata.gz: c2457159e21684fbdb72367753c52204de25393f74ee715622ad9879a6b228477f580440e516fee5c0d47ea6c198f8568bd109912abb2cbb01704e1e84d94d79
-  data.tar.gz: 0ba0bd0264f57f0334312c897a07b3023bd2019e835c8ec88e6e9bd827aa6af80c4a7610c1f1198958bb8948da8e2ed4981c56b725b371086df2e8950661ab07
+  metadata.gz: 3729efcd7dcfa5964a408fb28750bd2ac7caea3af323b1ea8c8b75503446f51805db7f20b05bfd705a9ac020bd06fe6fba5135013137e937f7dd6f499e134f40
+  data.tar.gz: d69918fdaf8ab491ac5bc21cd7a838048ef4eaf2299d8a867eea017b14c0f5ca3a314e7106e6fc0bf00fad8e949550efaae897121d8ae11de4d964a1a0231218

data/docs/application.md

@@ -158,6 +158,8 @@ 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`. 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.

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_syntax.md

@@ -75,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:
 

data/docs/plugins.md

@@ -372,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
 

data/lib/VERSION

@@ -1 +1 @@
-7.1
+7.1.1

data/lib/VERSION_NOTES

@@ -1,3 +1,10 @@
+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.

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
 
       #

data/lib/gloo/core/invoker.rb

@@ -18,26 +18,39 @@ module Gloo
       #
       # Resolve, validate and invoke the function at the given
       # target path, with the given raw (unevaluated) arg tokens.
-      # Reports an error and returns nil for any failure - including
-      # a failure inside the function itself (see Function#invoke,
-      # which leaves `it` alone rather than setting it to an
-      # unreliable result when that happens).
+      # For any failure, reports an error, puts false in `it` and
+      # returns nil - before the call (see failed), or inside the
+      # function itself (see Function#invoke).
       #
       def self.invoke( engine, target, arg_tokens )
         if target.nil? || target.to_s.strip.empty?
           engine.syntax_err NO_TARGET_ERR
-          return nil
+          return failed( engine )
         end
 
         func = resolve_function( engine, target )
-        return nil unless func
+        return failed( engine ) unless func
 
+        # An arg that couldn't be worked out was already reported, but
+        # the function's own error tracking would clear it if the call
+        # went ahead.
+        errors_before = engine.heap.error.error_count
         args = evaluate_arg_tokens( engine, arg_tokens )
-        return nil unless params_count_ok?( engine, func, args )
+        return failed( engine ) if engine.heap.error.error_count > errors_before
+        return failed( engine ) unless params_count_ok?( engine, func, args )
 
         return invoke_function( engine, func, args )
       end
 
+      #
+      # The function couldn't be called (the problem was already
+      # reported): put false in `it`, and return nil.
+      #
+      def self.failed( engine )
+        engine.heap.it.set_to false
+        return nil
+      end
+
       #
       # Resolve the function object at the target path. Reports an
       # error and returns nil if the path doesn't resolve to

data/lib/gloo/core/verb.rb

@@ -94,15 +94,26 @@ module Gloo
       def take_evaluated_arg
         return true unless @params
 
-        errors_before = @engine.heap.error.error_count
-        value = Gloo::Expr::Expression.new( @engine, @params.tokens ).evaluate
-        return false if @engine.heap.error.error_count > errors_before
+        value, ok = evaluate_expr( @params.tokens )
+        return false unless ok
 
         @tokens = @tokens.with_token( value.to_s )
         @params = nil
         return true
       end
 
+      #
+      # Work out an expression from the given tokens. Returns the value
+      # and whether it worked: false if the expression reported a
+      # problem (already reported), in which case the value is whatever
+      # it had worked out so far.
+      #
+      def evaluate_expr( tokens )
+        errors_before = @engine.heap.error.error_count
+        value = Gloo::Expr::Expression.new( @engine, tokens ).evaluate
+        return value, @engine.heap.error.error_count == errors_before
+      end
+
       #
       # Run the verb.
       #

data/lib/gloo/exec/exec_env.rb

@@ -35,13 +35,16 @@ module Gloo
       end
 
       #
-      # Where the line now running is, for error messages: the running
-      # script and its line, or the file and line being loaded.
+      # Where the line now running is, for error messages: the file and
+      # line being loaded, or the running script and its line. While a
+      # file is being read, a problem is in that file, even when a
+      # script started the load.
       #
       def current_location
+        return @load_location if @load_location
         return @running_script.location if @running_script
 
-        return @load_location
+        return nil
       end
 
       #

data/lib/gloo/exec/script.rb

@@ -65,6 +65,13 @@ module Gloo
         @break_out = true
       end
 
+      #
+      # Did a break end this script's run?
+      #
+      def broke_out?
+        return @break_out
+      end
+
     end
   end
 end

data/lib/gloo/objs/basic/script.rb

@@ -115,6 +115,15 @@ module Gloo
       def msg_run
         s = Gloo::Exec::Script.new( @engine, self )
         s.run
+        @broke_out = s.broke_out?
+      end
+
+      #
+      # Did a break end this script's last run? A loop uses this to
+      # stop when its do script breaks.
+      #
+      def broke_out?
+        return @broke_out == true
       end
 
       # ---------------------------------------------------------------------

data/lib/gloo/objs/ctrl/each.rb

@@ -43,13 +43,15 @@ module Gloo
       end
 
       #
-      # Run the do script once.
+      # Run the do script once. Returns true if a break in it ended the
+      # run, so the loop should stop.
       #
       def run_do
         o = find_child DO
-        return unless o
+        return false unless o
 
         Gloo::Exec::Dispatch.message( @engine, 'run', o )
+        return o.respond_to?( :broke_out? ) && o.broke_out?
       end
 
 

data/lib/gloo/objs/ctrl/each_child.rb

@@ -130,7 +130,7 @@ module Gloo
           end
 
           set_child child
-          @iterator_obj.run_do
+          break if @iterator_obj.run_do
         end
 
         if group_mode && !first_time

data/lib/gloo/objs/ctrl/each_dir.rb

@@ -58,7 +58,7 @@ module Gloo
           next unless File.directory?( f )
 
           set_dir f
-          @iterator_obj.run_do
+          break if @iterator_obj.run_do
         end
       end
 

data/lib/gloo/objs/ctrl/each_file.rb

@@ -60,7 +60,7 @@ module Gloo
           next unless include?( f )
 
           set_file f
-          @iterator_obj.run_do
+          break if @iterator_obj.run_do
         end
       end
 

data/lib/gloo/objs/ctrl/each_line.rb

@@ -48,7 +48,7 @@ module Gloo
 
         str.each_line do |line|
           set_line line
-          @iterator_obj.run_do
+          break if @iterator_obj.run_do
         end
       end
 

data/lib/gloo/objs/ctrl/each_word.rb

@@ -48,7 +48,7 @@ module Gloo
 
         str.split( ' ' ).each do |word|
           set_word word
-          @iterator_obj.run_do
+          break if @iterator_obj.run_do
         end
       end
 

data/lib/gloo/objs/ctrl/repeat.rb

@@ -37,13 +37,15 @@ module Gloo
       end
 
       #
-      # Run the do script once.
+      # Run the do script once. Returns true if a break in it ended the
+      # run, so the loop should stop.
       #
       def run_do
         o = find_child DO
-        return unless o
+        return false unless o
 
         Gloo::Exec::Dispatch.message( @engine, 'run', o )
+        return o.respond_to?( :broke_out? ) && o.broke_out?
       end
 
       #
@@ -98,7 +100,7 @@ module Gloo
       def msg_run
         times.times do |index|
           set_index index
-          run_do
+          break if run_do
         end
       end
 

data/lib/gloo/objs/str_utils/cipher.rb

@@ -209,7 +209,8 @@ module Gloo
         {
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
-          :description => 'Tool to encrypt and decrypt data.',
+          :description => 'Tool to encrypt and decrypt data, with ' \
+            'AES-256-CBC.',
           :children => [
             'key (string) — The encryption key. Base64 encoded.',
             'init_vector (string) — The initialization vector. Base64 encoded.',
@@ -218,8 +219,15 @@ module Gloo
           :messages => [
             'generate_keys — Generate an encryption key and initialization vector. The keys are base64 encoded.',
             'encrypt — Encrypt the data. The data child is changed. It will have the encrypted data.',
-            'decrypt — Decrypt the data. The data child is changed. It will have the decrypted data.'
+            'decrypt — Decrypt the data. The data child is changed. It will have the decrypted data. With the wrong key or init_vector, decrypt usually reports an error and it is false; but not always (see notes).'
           ],
+          :notes => 'AES-CBC can\'t always tell that a key is wrong. A ' \
+            'wrong key usually leaves the decrypted data with padding ' \
+            'that doesn\'t check out, which is reported as an error. But ' \
+            'about 1 time in 256 the padding happens to look right: then ' \
+            'decrypt reports nothing, and the data is garbage rather than ' \
+            'the original. To be sure the key is right, keep a value you ' \
+            'can check, such as encrypting a known word alongside the data.',
           :examples => <<~EXAMPLES.strip
             #
             # Encrypt and Decrypt a string.

data/lib/gloo/persist/declaration_ledger.rb

@@ -14,11 +14,10 @@ module Gloo
       attr_reader :roots
 
       #
-      # Set up a ledger for the file at pn.
+      # Set up a ledger for one file's load.
       #
-      def initialize( engine, pn )
+      def initialize( engine )
         @engine = engine
-        @pn = pn
         @roots = []
         @mine = {}.compare_by_identity
       end
@@ -43,15 +42,16 @@ module Gloo
       # `value`. If another file created it and the values differ, the
       # new value is being ignored -- warn so it isn't a surprise. A
       # duplicate name inside one file is left alone (a documented
-      # "first one wins").
+      # "first one wins"). The warning's location (this file and line)
+      # comes from the load.
       #
       def clash( prior, name, value )
         return if @mine.key?( prior )
         return if value.nil? || value.to_s.strip.empty?
         return if prior.value.to_s == value.to_s
 
-        @engine.log.warn(
-          "#{@pn}: '#{name}' is already declared in another loaded file with a " \
+        @engine.warn(
+          "'#{name}' is already declared in another loaded file with a " \
           "different value (#{prior.value.inspect} kept, #{value.inspect} ignored)."
         )
       end

data/lib/gloo/persist/file_loader.rb

@@ -53,7 +53,7 @@ module Gloo
         @trivia = Gloo::Persist::TriviaBuffer.new
         @body = Gloo::Persist::ScriptBodyCollector.new
         @shorthand = Gloo::Persist::ShorthandExpander.new( engine )
-        @ledger = Gloo::Persist::DeclarationLedger.new( engine, pn )
+        @ledger = Gloo::Persist::DeclarationLedger.new( engine )
         @in_block = false
         @block_value = ''
         @body_started = false

data/lib/gloo/persist/persist_man.rb

@@ -396,7 +396,7 @@ module Gloo
       #
       def warn_if_dirty( fs )
         saver = Gloo::Persist::FileSaver.new( @engine, fs.pn, fs.obj, fs.source_doc )
-        @engine.log.warn "#{RELOAD_DIRTY_WARNING}#{fs.pn}" if saver.dirty?
+        @engine.warn "#{RELOAD_DIRTY_WARNING}#{fs.pn}" if saver.dirty?
       end
 
     end

data/lib/gloo/verbs/break.rb

@@ -51,11 +51,16 @@ module Gloo
         {
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
-          :description => 'Break out of the current script, stop running.',
+          :description => 'Break out of the current script, stop running. ' \
+            'If that script is the do script of a loop (repeat, or any ' \
+            'kind of each), the whole loop ends.',
           :syntax => [ 'break' ],
           :result => 'No more commands are executed in the currently ' \
             'running script. If there are other scripts in the stack, ' \
-            'they will resume normally.',
+            'they will resume normally. In a loop\'s do script, the loop ' \
+            'ends too and runs no more passes; the script that ran the ' \
+            'loop carries on. A break in a script the do script runs ' \
+            '(eg. with run) ends only that script, not the loop.',
           :examples => <<~EXAMPLES.strip
             #
             # Break out of a script.

data/lib/gloo/verbs/eval.rb

@@ -30,9 +30,8 @@ module Gloo
       #
       def run
         if @tokens.token_count > 1
-          expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-          result = expr.evaluate
-          @engine.heap.it.set_to result
+          result, ok = evaluate_expr( @tokens.params )
+          @engine.heap.it.set_to( ok ? result : false )
         else
           @engine.heap.it.set_to true
         end
@@ -61,7 +60,9 @@ module Gloo
             '{expression} — The expression that will be evaluated. The expression is optional. If not provided, eval will result in true.'
           ],
           :result => 'The result of the expression evaluation is put ' \
-            'into it. No other action is performed.',
+            'into it. No other action is performed. If the expression ' \
+            'fails (eg. it names a missing object), the error is ' \
+            'reported and it is false.',
           :examples => <<~EXAMPLES.strip,
             > eval "me"
             > eval "hello " "world"

data/lib/gloo/verbs/invoke.rb

@@ -60,7 +60,8 @@ module Gloo
             '{path.to.function} — The function we want to invoke.',
             '{params} — The list of parameters to the function.'
           ],
-          :result => 'The result of the function is put into it. The ' \
+          :result => 'The result of the function is put into it; if ' \
+            'anything goes wrong, it is false. The ' \
             'inline forms (invoke(...), ~>(...)) can be used anywhere ' \
             'an expression is evaluated - show, put ... into, if, ' \
             'unless, eval, and more - and evaluate to the result ' \
@@ -69,13 +70,13 @@ module Gloo
             "#{Gloo::Core::Invoker::NO_TARGET_ERR} — No function reference was given.",
             "Object '{path.to.function}' was not found. — The path doesn't resolve to any object.",
             "#{Gloo::Core::Invoker::NOT_FUNCTION_ERR}{path.to.function} — The path resolves to an object that isn't a function.",
-            "#{Gloo::Core::Invoker::PARAM_COUNT_ERR}{path.to.function} (expected N, got N) — The number of params given doesn't match what the function declares."
+            "#{Gloo::Core::Invoker::PARAM_COUNT_ERR}{path.to.function} (expected N, got N) — The number of params given doesn't match what the function declares.",
+            "Object '{param}' was not found. — A param names an object that doesn't exist. The function isn't run."
           ],
           :notes => 'If the function itself fails during invocation ' \
-            '(its on_invoke script hits an error), it is left ' \
-            'unchanged rather than being set to an unreliable result. ' \
-            'The underlying error is whatever was reported by the ' \
-            'failure inside the function. ' \
+            '(its on_invoke script hits an error), it is false rather ' \
+            'than an unreliable result. The underlying error is ' \
+            'whatever was reported by the failure inside the function. ' \
             'Inline call params are space-separated, same as the ' \
             'standalone verb - each one is evaluated as a single ' \
             'token (a literal or object reference), not a multi-token ' \

data/lib/gloo/verbs/log.rb

@@ -50,11 +50,12 @@ module Gloo
       # Write to the specified logger.
       # 
       def write_to_log
-        expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-        result = expr.evaluate
+        # A failed expression is still logged as far as it got, but it
+        # is false.
+        result, ok = evaluate_expr( @tokens.params )
         level = log_level_specified( result )
         @engine.log.write result, level
-        @engine.heap.it.set_to result
+        @engine.heap.it.set_to( ok ? result : false )
       end
 
       # 
@@ -106,7 +107,10 @@ module Gloo
               'not specified, the message is written as DEBUG level.'
           ],
           :result => 'The message is written to the log at the ' \
-            'specified level. It will contain the log message.',
+            'specified level. It will contain the log message. If the ' \
+            'expression fails, the error is reported and what was ' \
+            'worked out so far is still logged, but it is false. A ' \
+            'level that can\'t be worked out falls back to debug.',
           :notes => "Use `log clear` from the CLI to clear out both the " \
             "standard log and the error log.\n\n" \
             "> log clear",

data/lib/gloo/verbs/show.rb

@@ -16,10 +16,11 @@ module Gloo
       #
       def run
         if @tokens.token_count > 1
-          expr = Gloo::Expr::Expression.new( @engine, @tokens.params )
-          result = expr.evaluate
+          # A failed expression is still shown as far as it got (a best
+          # guess, and handy when debugging), but it is false.
+          result, ok = evaluate_expr( @tokens.params )
           @engine.log.show get_formatted_string( result )
-          @engine.heap.it.set_to result
+          @engine.heap.it.set_to( ok ? result : false )
         else
           @engine.log.show ''
         end
@@ -46,14 +47,16 @@ module Gloo
       private
 
       #
-      # Get the formatted string.
+      # Get the formatted string: in the color given in the params, if
+      # any. A color that can't be worked out (already reported) shows
+      # the string plain.
       #
       def get_formatted_string( str )
         if @params&.token_count&.positive?
-          expr = Gloo::Expr::Expression.new( @engine, @params.tokens )
-          val = expr.evaluate
-          color = val.to_sym
-          return @engine.platform.get_colorized_string( str, color )
+          val, ok = evaluate_expr( @params.tokens )
+          return str unless ok && val
+
+          return @engine.platform.get_colorized_string( str, val.to_sym )
         end
         return str
       end
@@ -79,11 +82,13 @@ module Gloo
             '{target} — The object that we want to see. The target ' \
               'might be the path to an object, a literal or an ' \
               'expression to be evaluated before being shown.',
-            '{color} — Optional color for the text.'
+            '{color} — Optional color for the text. If the color can\'t be worked out, the error is reported and the text is shown plain.'
           ],
           :result => "The object's value is shown, or the literal, or " \
             'the result of the evaluated expression is shown. It will ' \
-            "contain the object's value.",
+            "contain the object's value. If the expression fails (eg. " \
+            'it names a missing object), the error is reported and ' \
+            'what was worked out so far is still shown, but it is false.',
           :examples => <<~EXAMPLES.strip,
             > show "me"
             > show "hello " "world"

data/test.gloo/lang/exceptions.test.gloo

@@ -23,6 +23,18 @@ tests.lang.exceptions [can] :
     kind [string] :
     location [string] :
 
+  # A scratch file with a mistake in it, for the location of an error in
+  # a loaded file.
+  broken_file [file] :
+  broken_name [string] : /gloo_exceptions_location.gloo
+  broken_src [text] : BEGIN
+broken_location_demo [can] :
+  count [int : 3
+END
+
+  on_load [script] :
+    put $.gloo_tmp ^.broken_name into ^.broken_file
+
   confirm_throw_fires_on_exception [test] :
     description [string] : Confirm throw fires on_exception and populates exception_data, but does not fire on_error.
     expect_errors [bool] : true
@@ -127,3 +139,13 @@ tests.lang.exceptions [can] :
       eval ^^.num = 0
       assert "expected the best guess, 0"
 
+  confirm_error_location_in_a_loaded_file [test] :
+    description [string] : an error in a file a script loads names that file and line, not the script.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.broken_file to write ( ^^.broken_src )
+      load ( ^^.broken_file )
+      check ^^.error_data.location for ends_with? ( 'gloo_exceptions_location.gloo:2' )
+      assert "expected the location to be the loaded file and line"
+      tell broken_location_demo to unload
+      tell ^^.broken_file to delete

data/test.gloo/objs/cipher.test.gloo

@@ -41,3 +41,30 @@ tests.objs.cipher [can] :
       tell tests.objs.cipher.b to decrypt
       eval tests.objs.cipher.b.data = ^^.plaintext
       assert "expected the second cipher to decrypt with the shared key"
+
+  # Fixed values, so the results never vary: 'hello' encrypted with key
+  # ('k' x 32) and iv ('i' x 16), and a wrong key ('0' x 32) whose
+  # garbage fails the padding check. (AES-CBC can't always tell a key is
+  # wrong: about 1 wrong key in 256 gives garbage with no error.)
+  fixed_iv [string] : aWlpaWlpaWlpaWlpaWlpaQ==
+  hello_encrypted [string] : aRyXOIIhJzBhh+BthfFstw==
+  wrong_key [string] : MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA=
+  err_fired [bool] : false
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  wrong_key_is_an_error [test] :
+    description [string] : decrypt with a wrong key that fails the padding check reports an error.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      create tests.objs.cipher.w as cipher
+      put ^^.wrong_key into tests.objs.cipher.w.key
+      put ^^.fixed_iv into tests.objs.cipher.w.init_vector
+      put ^^.hello_encrypted into tests.objs.cipher.w.data
+      tell tests.objs.cipher.w to decrypt
+      eval it = false
+      assert "expected it to be false"
+      eval ^^.err_fired = true
+      assert "expected on_error to fire for the wrong key"

data/test.gloo/objs/int.test.gloo

@@ -48,10 +48,13 @@ tests.objs.int [can] :
       eval ^^.a <= 100
       assert "expected it to be less than or equal to 100"
           
+      # A random value is only checked for its range: two random values
+      # are equal now and then, so 'not equal' would fail at random.
       tell ^^.a to randomize (10000)
-      tell ^^.b to randomize (10000)
-      eval ^^.a = ^^.b
-      refute "expected them to not be equal"
+      eval ^^.a >= 0
+      assert "expected it to be greater than or equal to 0"
+      eval ^^.a < 10000
+      assert "expected it to be less than 10000"
 
   format_int [test] :
     description [string] : Format an integer

data/test.gloo/verbs/break.test.gloo

@@ -18,3 +18,69 @@ tests.verbs.break [can] :
       tell ^^.s to run
       eval ^^.b
       assert "expected b to be true"
+
+  # Loops whose do script breaks on its second pass.
+  passes [int] : 0
+  after [int] : 0
+
+  rep [repeat] :
+    times [int] : 4
+    index [int] :
+    do [script] :
+      put tests.verbs.break.passes + 1 into tests.verbs.break.passes
+      if tests.verbs.break.passes = 2 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  kids [can] :
+    a [string] : a
+    b [string] : b
+    c [string] : c
+
+  each_kid [each] :
+    child [alias] :
+    in [alias] : tests.verbs.break.kids
+    do [script] :
+      put tests.verbs.break.passes + 1 into tests.verbs.break.passes
+      if tests.verbs.break.passes = 2 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  inner [repeat] :
+    times [int] : 3
+    index [int] :
+    do [script] :
+      if tests.verbs.break.inner.index = 1 then break
+      put tests.verbs.break.after + 1 into tests.verbs.break.after
+
+  outer [repeat] :
+    times [int] : 2
+    index [int] :
+    do [script] :
+      tell tests.verbs.break.inner to run
+
+  break_ends_a_repeat [test] :
+    description [string] : break in a repeat's do script ends the loop.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      tell ^^.rep to run
+      eval ^^.passes = 2
+      assert "expected the loop to stop on the pass that broke"
+      eval ^^.after = 1
+      assert "expected only the first pass to get past the break"
+
+  break_ends_an_each [test] :
+    description [string] : break in an each's do script ends the loop.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      tell ^^.each_kid to run
+      eval ^^.passes = 2
+      assert "expected the loop to stop on the pass that broke"
+
+  break_ends_only_the_inner_loop [test] :
+    description [string] : break in an inner loop ends that loop, not the outer one.
+    on_test [script] :
+      put 0 into ^^.after
+      tell ^^.outer to run
+      eval ^^.after = 2
+      assert "expected each of the 2 inner loops to get past its break once"

data/test.gloo/verbs/eval.test.gloo

@@ -15,3 +15,11 @@ tests.verbs.eval [can] :
 
       eval false
       refute "expected false to be false"
+
+  failed_expression_puts_false_in_it [test] :
+    description [string] : eval of an expression that fails puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 1 + no_such_obj_xyz
+      eval it = false
+      assert "expected it to be false after a failed expression"

data/test.gloo/verbs/invoke.test.gloo

@@ -90,3 +90,53 @@ tests.verbs.invoke [can] :
       show invoke( tests.verbs.invoke.greet "Bob Smith" )
       eval it = "Hi, Bob Smith"
       assert "expected it to be 'Hi, Bob Smith'"
+
+  wrong_param_count_sets_it_false [test] :
+    description [string] : invoke with the wrong number of params puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'Hi'
+      invoke tests.verbs.invoke.add 1
+      eval it = false
+      assert "expected it to be false after a failed invoke"
+
+  shortcut_wrong_param_count_sets_it_false [test] :
+    description [string] : ~> with the wrong number of params puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'Hi'
+      ~> tests.verbs.invoke.add 1
+      eval it = false
+      assert "expected it to be false after a failed ~>"
+
+  not_a_function_sets_it_false [test] :
+    description [string] : invoke of something that isn't a function puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'Hi'
+      invoke tests.verbs.invoke.total
+      eval it = false
+      assert "expected it to be false after invoking a non-function"
+
+  missing_arg_object_is_an_error [test] :
+    description [string] : an argument naming a missing object fires on_error and puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      eval 'Hi'
+      invoke tests.verbs.invoke.add no_such_obj_xyz 4
+      eval it = false
+      assert "expected it to be false"
+      eval ^^.err_fired = true
+      assert "expected on_error to fire for the missing argument"
+
+  inline_failure_in_put_sets_it_false [test] :
+    description [string] : a failed invoke( ... ) inside put puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      put 5 into ^^.total
+      put invoke( tests.verbs.invoke.add 1 ) into ^^.total
+      eval it = false
+      assert "expected it to be false"
+      eval ^^.total = 5
+      assert "expected the target to keep its value"

data/test.gloo/verbs/log.test.gloo

@@ -10,3 +10,19 @@ tests.verbs.log [can] :
       log 'debug' (debug)
       eval it = 'debug'
       assert "expected it to be 'debug'"
+
+  failed_expression_puts_false_in_it [test] :
+    description [string] : log of an expression that fails puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      log 1 + no_such_obj_xyz
+      eval it = false
+      assert "expected it to be false after a failed expression"
+
+  failed_level_puts_the_value_in_it [test] :
+    description [string] : log with a level that fails still puts the value in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      log 'plain' (no_such_obj_xyz)
+      eval it = 'plain'
+      assert "expected the value in it when only the level fails"

data/test.gloo/verbs/show.test.gloo

@@ -33,3 +33,35 @@ tests.verbs.show [can] :
       show 'a' + 'b'
       eval it = 'ab'
       assert "expected it to be 'ab'"
+
+  add [ƒ] :
+    on_invoke [script] :
+      put ^.params.x + ^.params.y into ^.result
+    params [can] :
+      x [int] :
+      y [int] :
+    result [int] :
+
+  failed_expression_puts_false_in_it [test] :
+    description [string] : show of an expression that fails puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      show 1 + no_such_obj_xyz
+      eval it = false
+      assert "expected it to be false after a failed expression"
+
+  failed_inline_invoke_puts_false_in_it [test] :
+    description [string] : show of an inline invoke that fails puts false in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      show invoke( tests.verbs.show.add 1 )
+      eval it = false
+      assert "expected it to be false after a failed inline invoke"
+
+  failed_color_puts_the_value_in_it [test] :
+    description [string] : show with a color that fails still puts the value in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      show 'plain' (no_such_obj_xyz)
+      eval it = 'plain'
+      assert "expected the value in it when only the color fails"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gloo
 version: !ruby/object:Gem::Version
-  version: '7.1'
+  version: 7.1.1
 platform: ruby
 authors:
 - Eric Crane