gloo 7.1 → 7.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 211368f27a7bbea86aed449d545c28f05a62857e92e8a3942394261a336e597b
-  data.tar.gz: 98ea31342225ac55d1ae499727fe2e71bf1679a8c4f1523651e57ac50829a714
+  metadata.gz: e3e9f9ec23fd38faee18f95a521fe1d21a8e572b2306c814233c3fc67ae6e5f3
+  data.tar.gz: a1f2f961d1860473c14faefb6c5f9ffe0556bae36479cf3755b8333a1b0db68c
 SHA512:
-  metadata.gz: c2457159e21684fbdb72367753c52204de25393f74ee715622ad9879a6b228477f580440e516fee5c0d47ea6c198f8568bd109912abb2cbb01704e1e84d94d79
-  data.tar.gz: 0ba0bd0264f57f0334312c897a07b3023bd2019e835c8ec88e6e9bd827aa6af80c4a7610c1f1198958bb8948da8e2ed4981c56b725b371086df2e8950661ab07
+  metadata.gz: d1665486b345b607c64f98519ac7219ac720ccad75d88d135a88225e3ea527871e6305acc95db9b31a89b7ba5373a6016b7fbcb0a354dfc82ecd04a3f5733bc9
+  data.tar.gz: 35f9a3c3013d394ed4be04106f682ef92b14328279b12524d345f5a5a04f4ce31d7c8645d38a48484ac699a0d9d8ccc231340004a90cb0b5acdb98f890809b58

data/Rakefile

@@ -2,8 +2,6 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  ENV[ 'GLOO_ENV' ] = 'TEST'
-
   t.warning = false
   t.libs << 'test'
   t.libs << 'lib'

data/docs/application.md

@@ -31,6 +31,8 @@ gloo [global option] [file]
 
 Running gloo with a file specified will run that file. Once that file is done, gloo will quit. However, by specifying `--cli`, once the file has finished, gloo will remain open in CLI mode.
 
+Gloo can also be started from another Ruby program; see Development, Running Gloo from Ruby.
+
 If a file named on the command line can't be found (a typo, the wrong folder, a missing `.gloo` extension on a full path), gloo prints `File '{name}' was not found.` to stderr and exits with a non-zero status. Any other load or run error also exits non-zero — including syntax errors in a file that otherwise loaded (gloo keeps loading past them, reporting each with its file and line) — so a shell script calling gloo can tell a failed run from a clean one.
 
 When specifying a file there are a couple ways to reference the gloo file to open:
@@ -76,6 +78,11 @@ When specifying a file there are a couple ways to reference the gloo file to ope
              - Exits with status 1 if any test failed, or errors or warnings
                were logged that no test expected; 0 otherwise.
              - See Testing.
+--embed      - Run in Embedded mode
+             - Start the engine and return, for a Ruby program that drives
+               gloo itself.
+             - This is the default when gloo is created in code with no file
+               or mode. See Development, Running Gloo from Ruby.
 --version    - Show application version
 --help       - Show the help screen
 ```
@@ -158,6 +165,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/development.md

@@ -1,6 +1,6 @@
 # Development
 
-How the interpreter's source is laid out, how to run its tests, and the conventions to follow when changing it. This page is for working on gloo itself; for using gloo, start with Getting Started.
+How the interpreter's source is laid out, how to run its tests, the conventions to follow when changing it, and how to run gloo from your own Ruby code. This page is for working on gloo itself or driving it from Ruby; for using gloo, start with Getting Started.
 
 **Contents**
 
@@ -8,6 +8,7 @@ How the interpreter's source is laid out, how to run its tests, and the conventi
 - Tests
 - Documentation
 - Reporting Errors
+- Running Gloo from Ruby
 
 ## Source Layout
 
@@ -40,7 +41,7 @@ There are two automated suites. Run both when making a change, and add to both:
 
 ### Unit tests — `test/`
 
-Standard Ruby minitest tests. The layout mirrors `lib/gloo/`, one test file per class or verb: `test/<area>/<name>_test.rb`, for example `test/verbs/show_test.rb` for `lib/gloo/verbs/show.rb`. Test classes inherit from `GlooTest` (in `test/base_test.rb`).
+Standard Ruby minitest tests. The layout mirrors `lib/gloo/`, one test file per class or verb: `test/<area>/<name>_test.rb`, for example `test/verbs/show_test.rb` for `lib/gloo/verbs/show.rb`. Test classes inherit from `BaseTest` (in `test/base_test.rb`), or from `BaseEngineTest` (in `test/base_engine_test.rb`) for a test that needs a started engine in `@engine`.
 
 ```
 rake test
@@ -98,3 +99,22 @@ Gloo reports every problem in a way scripts can see (see Language, Syntax, Error
 - A question whose answer is "no" is just a result, not an error.
 
 Don't use `@engine.log.error` or `@engine.log.warn` for these; they only write to the log, and scripts can't see them. Build "not found" messages with `Gloo::Core::NotFound` (for example `NotFound.object( name )`) so they always read the same way.
+
+## Running Gloo from Ruby
+
+Gloo can be started from another Ruby program, such as a test harness or an app that runs gloo commands. Create the engine with the params gloo should see — the same words you would type after `gloo` on the command line:
+
+```ruby
+require 'gloo'
+
+context = Gloo::App::EngineContext.new( [] )
+engine = Gloo::App::Engine.new( context )
+engine.start
+
+engine.process_cmd "create greeting as string : 'hello'"
+engine.process_cmd 'show greeting'
+```
+
+Only those params are used. The Ruby program's own command line (`ARGV`) is never read, so running `ruby harness.rb some_file.gloo` doesn't make gloo load `some_file.gloo`. Pass anything gloo should see explicitly. Only the `gloo` command itself (`Gloo.run`) reads the command line.
+
+With no file and no mode switch, the engine runs in Embedded mode (`--embed`): `start` sets the engine up and returns without loading or running anything, and your code drives it from there, for example with `process_cmd`.

data/docs/iterators.md

@@ -9,6 +9,7 @@
 - Each Line
 - Each Word
 - Repeat
+- Ending a Loop Early
 
 ## Each
 
@@ -214,7 +215,7 @@ Iterate for each line in a text block (string).
 Children:
 
 - `line` (string)
-    - The single line of text.
+    - The single line of text, without its line ending (`\n` or `\r\n`). A blank line is still visited, as an empty string.
 - `in` (text)
     - The block of text or string.
 - `do` (script)
@@ -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/docs/verbs.md

@@ -86,12 +86,13 @@ If the destination doesn't exist, or the expression can't be worked out (eg. it
 
 ## Load & Save
 
-`load` reads a `.gloo` file into the heap and runs its `on_load` script. Give a path relative to the project folder (no extension needed) or a full path (extension required); `*` in place of a file name loads every `.gloo` file in a folder.
+`load` reads a `.gloo` file into the heap and runs its `on_load` script. Give a path relative to the project folder, a full path, or one starting with `~` for your home folder; the `.gloo` extension is optional. `*` in place of a file name loads every `.gloo` file in a folder, wherever the folder is. Anything before the `*` is the start of the file names, so `my/app/a*` loads just the files whose names start with `a`.
 
 ```gloo
 > load my/project/config
 > load my/app/*
 > load ~/.my_app/settings.gloo
+> load ~/.my_app/plugins/*
 ```
 
 If the name can't be resolved to a file, `load` reports `File '{name}' was not found.` — it fires `on_error` and, when the file was named on the `gloo` command line, prints the message to stderr and exits non-zero. A bad or missing file never fails silently.

data/lib/VERSION

@@ -1 +1 @@
-7.1
+7.1.2

data/lib/VERSION_NOTES

@@ -1,3 +1,19 @@
+7.1.2 - 2026.10.28
+ - Fixes bug with create verb and ^.here reference.
+ - Behaviour change: an each over lines gives each line without its line ending.
+ - Load with * now works for a full path or a ~ folder, not just a folder in the project.
+ - Load no longer needs the .gloo extension for a full or ~ path.
+ - Clean run of gloo from a different ruby process (or test).
+ - Fixes looking for each child with a group by.
+
+
+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/args.rb

@@ -12,7 +12,6 @@ module Gloo
     class Args
 
       QUIET = 'quiet'.freeze
-      GLOO_ENV = 'GLOO_ENV'.freeze
 
       attr_reader :switches, :files, :app_path, :command_tokens
 
@@ -26,8 +25,9 @@ module Gloo
         @app_path = nil
         @command_tokens = []
 
+        # Only the params given; the host process's ARGV is read by
+        # Gloo.run, when gloo is run as the command.
         params.each { |o| process_one_arg( o ) }
-        ARGV.each { |o| process_one_arg( o ) }
       end
 
       #
@@ -117,9 +117,7 @@ module Gloo
       # Then finally use the default: embedded mode.
       #
       def detect_mode
-        mode = if ENV[ GLOO_ENV ] == Gloo::App::Mode::TEST.to_s
-                 Mode::TEST
-               elsif app?
+        mode = if app?
                  Mode::APP
                elsif version?
                  Mode::VERSION

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/pn.rb

@@ -172,7 +172,12 @@ module Gloo
       # returns nil without reporting an error. A caller that needs the
       # object reports its own error.
       #
+      # A here (^) or context (@) reference is expanded first, as resolve
+      # does, so a new object's parent can be given the same way as any
+      # other path (eg. create ^.x inside a script).
+      #
       def get_parent
+        expand_refs
         o = @engine.heap.root
 
         if self.includes_path?

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
 
 
@@ -132,7 +134,7 @@ module Gloo
             'One of the following, whose presence determines which kind of loop this is:',
             'child (alias) — iterate a container\'s children.',
             'word (string) — iterate the words in a string.',
-            'line (string) — iterate the lines in a block of text.',
+            'line (string) — iterate the lines in a block of text. Each line comes without its line ending; a blank line is visited as an empty string.',
             'file (file) — iterate the files in a folder. Optional children: ext (string) limits to files of that extension, ignoring case; recursive (bool) walks the subfolders too; include_dirs (bool) lists folders as well as files.',
             'dir (file) — iterate the directories in a folder. Optional child: recursive (bool) walks the subfolders too.'
           ],

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

@@ -116,21 +116,25 @@ module Gloo
 
         o = Gloo::Objs::Alias.resolve_alias( @engine, o )
         o.children.each do |child|
+          new_group = false
           if group_mode
             group_value = group_by_value( child )
             if last_group != group_value
               last_group = group_value
+              new_group = true
+              # The ending group's end runs while child is still its last child.
               if first_time
                 first_time = false
               else
                 run_on_group_end
               end
-              run_on_group_start
             end
           end
 
           set_child child
-          @iterator_obj.run_do
+          # The new group's start runs once child is its first child.
+          run_on_group_start if new_group
+          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

@@ -40,15 +40,16 @@ module Gloo
       # ---------------------------------------------------------------------
 
       #
-      # Run for each line.
+      # Run for each line, without its line ending (\n or \r\n). A blank
+      # line is still visited, as an empty string.
       #
       def run
         str = @iterator_obj.in_value
         return unless str
 
-        str.each_line do |line|
+        str.each_line( chomp: true ) 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