gloo 6.7.2 → 7.0.1

data/lib/gloo/verbs/unload.rb

@@ -16,6 +16,7 @@ module Gloo
       # This will unload all loaded objects and reset the engine state.
       #
       def run
+        return if extra_words_err?( 'nothing was unloaded; to unload one object, use tell x to unload' )
         return unless @engine.persist_man.maps
         
         @engine.persist_man.unload_all
@@ -58,6 +59,13 @@ module Gloo
             'save state prior to executing.',
           :syntax => [ 'unload' ],
           :result => 'All objects will be unloaded from the heap.',
+          :errors => [
+            'unload takes no object, so nothing was unloaded — anything ' \
+              'written after unload is an error, and nothing is unloaded. ' \
+              'To unload one object, use tell x to unload.'
+          ],
+          :notes => 'unload takes no object; to unload just one object, ' \
+            'send it the unload message (tell x to unload).',
           :examples => <<~EXAMPLES.strip
             > unload
           EXAMPLES

data/test.gloo/ctrl/each.test.gloo

@@ -35,3 +35,91 @@ tests.ctrl.each [can] :
       tell ^^.rpt to run
       eval ^^.count = 3
       assert "expected repeat to run 3 times"
+
+#
+# Each file / each dir over a nested folder tree.
+# The tree is built under /tmp and removed at the end.
+#
+
+tests.ctrl.each_folder [can] :
+
+  count [int] : 0
+
+  make_tree [system] :
+    command [string] : rm -rf /tmp/gloo_each_walk && mkdir -p /tmp/gloo_each_walk/a/deep /tmp/gloo_each_walk/.obs && touch /tmp/gloo_each_walk/top.md /tmp/gloo_each_walk/notes.txt /tmp/gloo_each_walk/a/x.md /tmp/gloo_each_walk/a/deep/Y.MD /tmp/gloo_each_walk/.obs/o.md
+    get_output [bool] : false
+  remove_tree [system] :
+    command [string] : rm -rf /tmp/gloo_each_walk
+    get_output [bool] : false
+
+  files [each] :
+    file [file] :
+    in [file] : /tmp/gloo_each_walk
+    ext [string] : md
+    recursive [bool] : true
+    do [script] :
+      eval ^^.count + 1
+      put it into ^^.count
+
+  wild [each] :
+    file [file] :
+    in [file] : /tmp/gloo_each_walk/**/
+    ext [string] : md
+    do [script] :
+      eval ^^.count + 1
+      put it into ^^.count
+
+  top [each] :
+    file [file] :
+    in [file] : /tmp/gloo_each_walk
+    do [script] :
+      eval ^^.count + 1
+      put it into ^^.count
+
+  dirs [each] :
+    dir [file] :
+    in [file] : /tmp/gloo_each_walk
+    recursive [bool] : true
+    do [script] :
+      eval ^^.count + 1
+      put it into ^^.count
+
+  recursive_each_file [test] :
+    description [string] : Recursive each file finds nested files, ignoring ext case and hidden folders.
+    on_test [script] :
+      tell ^^.make_tree to run
+      put 0 into ^^.count
+      tell ^^.files to run
+      eval ^^.count = 3
+      assert "expected top.md, a/x.md and a/deep/Y.MD"
+      tell ^^.remove_tree to run
+
+  wildcard_in_folder [test] :
+    description [string] : A ** wildcard in the folder walks the tree too.
+    on_test [script] :
+      tell ^^.make_tree to run
+      put 0 into ^^.count
+      tell ^^.wild to run
+      eval ^^.count = 3
+      assert "expected the same 3 files as recursive"
+      tell ^^.remove_tree to run
+
+  files_only_by_default [test] :
+    description [string] : Each file without ext lists files, not folders.
+    on_test [script] :
+      tell ^^.make_tree to run
+      put 0 into ^^.count
+      tell ^^.top to run
+      eval ^^.count = 2
+      assert "expected top.md and notes.txt, but not the folder a"
+      tell ^^.remove_tree to run
+
+  recursive_each_dir [test] :
+    description [string] : Recursive each dir lists every folder in the tree, skipping hidden ones.
+    on_test [script] :
+      tell ^^.make_tree to run
+      put 0 into ^^.count
+      tell ^^.dirs to run
+      eval ^^.count = 2
+      assert "expected a and a/deep"
+      tell ^^.remove_tree to run

data/test.gloo/dt/datetime.test.gloo

@@ -5,15 +5,17 @@
 tests.dt.datetime [can] :
 
   d [dt] :
+  # Only the now test uses this; the others set d, and tests run in random order.
+  fresh [dt] :
 
   now [test] :
     description [string] : Get the current datetime
     on_test [script] :
-      check ^^.d for blank?
+      check ^^.fresh for blank?
       assert "expected new datetime to be blank"
 
-      tell ^^.d to now
-      check ^^.d for blank?
+      tell ^^.fresh to now
+      check ^^.fresh for blank?
       refute "expected datetime to not be blank after now"
 
   is_today [test] :

data/test.gloo/lang/convert.test.gloo

@@ -13,6 +13,7 @@ tests.lang.convert [can] :
 
   string_to_number [test] :
     description [string] : a string is converted to the leading number for an int or decimal target.
+    expect_errors [bool] : true
     on_test [script] :
       put '3 third time' into ^^.i
       eval ^^.i = 3

data/test.gloo/lang/declaration.test.gloo

@@ -0,0 +1,38 @@
+#
+# Declaration syntax tests
+#
+
+tests.lang.declaration [can] :
+
+  # A fixture deliberately missing the ']' after its type, loaded inside
+  # its test so the syntax error it reports belongs to that test.
+  # Loading reads the type as 'int' anyway.
+  unclosed_file [file] : /tmp/gloo_declaration_test.gloo
+  unclosed_src [text] : BEGIN
+declaration_fixture [container] :
+  unclosed [int : 7
+END
+
+  closed_then_colon [int]: 8
+
+  type_missing_its_closing_bracket [test] :
+    description [string] : a type missing its ']' is still read as that type, with its value.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.unclosed_file to write ( ^^.unclosed_src )
+      load /tmp/gloo_declaration_test.gloo
+      eval declaration_fixture.unclosed = 7
+      assert "expected the value 7"
+
+      put '12' into declaration_fixture.unclosed
+      eval declaration_fixture.unclosed = 12
+      assert "expected it to still be an integer"
+
+      tell declaration_fixture to unload
+      tell ^^.unclosed_file to delete
+
+  closed_type_followed_by_the_colon [test] :
+    description [string] : a ']' followed directly by ':' is a normal declaration.
+    on_test [script] :
+      eval ^^.closed_then_colon = 8
+      assert "expected the value 8"

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

@@ -20,9 +20,12 @@ tests.lang.exceptions [can] :
   error_data [can] :
     message [string] :
     backtrace [string] :
+    kind [string] :
+    location [string] :
 
   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
     on_test [script] :
       put false into ^^.exc_fired
       put false into ^^.err_fired
@@ -40,6 +43,7 @@ tests.lang.exceptions [can] :
 
   confirm_execution_continues_after_throw [test] :
     description [string] : Confirm execution continues with the next line after a throw.
+    expect_errors [bool] : true
     on_test [script] :
       throw "boom"
       eval 2 + 2
@@ -48,6 +52,7 @@ tests.lang.exceptions [can] :
 
   confirm_on_error_still_works [test] :
     description [string] : Confirm on_error still fires for a genuine gloo-level error, independent of on_exception.
+    expect_errors [bool] : true
     on_test [script] :
       put false into ^^.exc_fired
       put false into ^^.err_fired
@@ -59,3 +64,66 @@ tests.lang.exceptions [can] :
 
       eval ^^.exc_fired = false
       assert "expected on_exception to NOT have fired for a gloo-level error"
+
+  confirm_missing_value_fires_on_error [test] :
+    description [string] : Using a missing object as a value is a runtime error, but asking whether it exists is not.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      exists? instance ^^.no_such_value
+      eval ^^.err_fired = false
+      assert "expected exists? on a missing object to not fire on_error"
+
+      show ^^.no_such_value
+      eval ^^.err_fired = true
+      assert "expected using a missing object as a value to fire on_error"
+
+      eval ^^.error_data.message = "Object '^^.no_such_value' was not found."
+      assert "expected error_data.message to name the missing object"
+
+  kept [string] : keep me
+
+  confirm_put_of_missing_value_keeps_target [test] :
+    description [string] : A put whose value uses a missing object leaves the target unchanged.
+    expect_errors [bool] : true
+    on_test [script] :
+      put 'keep me' into ^^.kept
+      put ^^.no_such_value into ^^.kept
+      eval ^^.kept = 'keep me'
+      assert "expected the target to keep its value"
+
+  confirm_error_kind [test] :
+    description [string] : error_data.kind says whether the command couldn't be understood (syntax) or couldn't be done (runtime).
+    expect_errors [bool] : true
+    on_test [script] :
+      nosuchverb
+      eval ^^.error_data.kind = 'syntax'
+      assert "expected an unknown verb to be a syntax error"
+
+      show ^^.no_such_value
+      eval ^^.error_data.kind = 'runtime'
+      assert "expected a missing object to be a runtime error"
+
+  confirm_error_location [test] :
+    description [string] : error_data.location names the script and line that failed.
+    expect_errors [bool] : true
+    on_test [script] :
+      show 1
+      show ^^.no_such_value
+      eval ^^.error_data.location = 'tests.lang.exceptions.confirm_error_location.on_test, line 2'
+      assert "expected the location of the failed line"
+
+  num [int] : 5
+
+  confirm_bad_value_is_a_warning [test] :
+    description [string] : A value that isn't really of its type is a warning, not an error; the best guess is used.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      put 'x' into ^^.num
+      eval ^^.err_fired = false
+      assert "expected a bad value to not fire on_error"
+
+      eval ^^.num = 0
+      assert "expected the best guess, 0"
+

data/test.gloo/lang/failures.test.gloo

@@ -0,0 +1,143 @@
+#
+# Predictable failures tests
+#
+# A failure a script can cause with ordinary bad input or the outside
+# world (invalid JSON, a template with a mistake, a value that isn't a
+# date) is a gloo runtime error: it fires on_error (not on_exception),
+# reads "Could not ...", and a command that would set it sets it false.
+#
+
+tests.lang.failures [can] :
+
+  err_fired [bool] : false
+  exc_fired [bool] : false
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  on_exception [script] :
+    put true into ^.exc_fired
+
+  error_data [can] :
+    message [string] :
+    backtrace [string] :
+    kind [string] :
+    location [string] :
+
+  j [json] : {bad
+  e [erb] :
+    template [text] : <%= 1 + %>
+    params [can] :
+    result [text] :
+  d [date] :
+  msg [string] :
+
+  invalid_json_is_an_error [test] :
+    description [string] : Pretty-printing invalid JSON fires on_error, not on_exception, and it is false.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      put false into ^^.exc_fired
+      tell ^^.j to pretty
+      eval it = false
+      assert "expected it to be false"
+
+      eval ^^.err_fired = true
+      assert "expected on_error to fire"
+      eval ^^.exc_fired = false
+      assert "expected on_exception not to fire"
+
+      put ^^.error_data.message into ^^.msg
+      check ^^.msg for starts_with? ( 'Could not parse the JSON in tests.lang.failures.j:' )
+      assert "expected the error to say what couldn't be done"
+
+  template_syntax_error_is_an_error [test] :
+    description [string] : An erb template with a syntax error is a gloo error, and gloo keeps running.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      put false into ^^.exc_fired
+      run ^^.e
+      eval it = false
+      assert "expected it to be false"
+
+      eval ^^.err_fired = true
+      assert "expected on_error to fire"
+      eval ^^.exc_fired = false
+      assert "expected on_exception not to fire"
+
+  not_a_date_is_an_error [test] :
+    description [string] : A date message on a value that isn't a date fires on_error, and it is false.
+    expect_errors [bool] : true
+    on_test [script] :
+      put '' into ^^.d
+      put false into ^^.err_fired
+      put false into ^^.exc_fired
+      tell ^^.d to mm
+      eval it = false
+      assert "expected it to be false"
+
+      eval ^^.err_fired = true
+      assert "expected on_error to fire"
+      eval ^^.exc_fired = false
+      assert "expected on_exception not to fire"
+
+  unknown_unit_is_an_error [test] :
+    description [string] : Adding an amount with an unknown unit fires on_error, and it is false.
+    expect_errors [bool] : true
+    on_test [script] :
+      put '2026-01-01' into ^^.d
+      put false into ^^.err_fired
+      tell ^^.d to add ( '3 dayz' )
+      eval it = false
+      assert "expected it to be false"
+
+      eval ^^.err_fired = true
+      assert "expected on_error to fire"
+
+      eval ^^.error_data.message = "'3 dayz' is not an amount like '1 day' or '3 months'."
+      assert "expected the error to show what an amount looks like"
+
+#
+# Chronic phrases are still dates: the checks above only catch a value
+# that couldn't be read as one.
+#
+
+tests.lang.chronic_phrases [can] :
+
+  d [date] :
+  now [date] :
+  dt [datetime] :
+  a [string] :
+  b [string] :
+
+  today_is_a_date [test] :
+    description [string] : put 'today' into a date gives today's date.
+    on_test [script] :
+      put 'today' into ^^.d
+      tell ^^.now to now
+      tell ^^.d to format ( '%Y-%m-%d' )
+      put it into ^^.a
+      tell ^^.now to format ( '%Y-%m-%d' )
+      put it into ^^.b
+      eval ^^.a = ^^.b
+      assert "expected 'today' to be today's date"
+
+  add_to_a_phrase [test] :
+    description [string] : A date set from a phrase can be added to.
+    on_test [script] :
+      put '2026-01-01' into ^^.d
+      tell ^^.d to add ( '1 week' )
+      eval it = '2026.01.08'
+      assert "expected a week later"
+
+  tomorrow_is_in_the_future [test] :
+    description [string] : 'tomorrow at 3pm' in a datetime is tomorrow, and in the future.
+    on_test [script] :
+      put 'tomorrow at 3pm' into ^^.dt
+      tell ^^.dt to is_tomorrow
+      assert "expected it to be tomorrow"
+      tell ^^.dt to is_future
+      assert "expected it to be in the future"
+      tell ^^.dt to is_past
+      refute "expected it not to be in the past"

data/test.gloo/lang/gloo_sys.test.gloo

@@ -4,6 +4,9 @@
 
 tests.lang.gloo_sys [can] :
 
+  # How many of the platform_*? checks are true.
+  platforms [int] : 0
+
   get_platform_info [test] :
     description [string] : Get the platform info.
     on_test [script] :
@@ -89,16 +92,18 @@ tests.lang.gloo_sys [can] :
       assert "expected screen_cols to be greater than 0"
 
   get_platform_os [test] :
-    description [string] : Get the platform OS.
+    description [string] : Exactly one of mac, windows and linux is true, on any platform.
     on_test [script] :
-      eval $.platform_mac? = true
-      assert "expected platform_mac to be true"
+      put 0 into ^^.platforms
+
+      eval $.platform_mac?
+      if it then tell ^^.platforms to inc
 
-      eval $.platform_windows? = false
-      assert "expected platform_windows to be false"
+      eval $.platform_windows?
+      if it then tell ^^.platforms to inc
 
-      eval $.platform_linux? = false
-      assert "expected platform_linux to be false"
+      eval $.platform_linux?
+      if it then tell ^^.platforms to inc
 
-      eval $.platform_wsl? = false
-      assert "expected platform_wsl to be false"
+      eval ^^.platforms = 1
+      assert "expected exactly one of platform_mac, platform_windows and platform_linux to be true"

data/test.gloo/lang/it.test.gloo

@@ -37,3 +37,142 @@ tests.lang.it [can] :
       list ^^.n
       eval it = 42
       assert "expected it to survive statements that don't produce a result"
+
+#
+# it is a read-only result value, not an object: it can be read, but
+# nothing can target it.
+#
+
+tests.lang.it_read_only [can] :
+
+  err_fired [bool] : false
+  s [string] :
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  error_data [can] :
+    message [string] :
+    backtrace [string] :
+    kind [string] :
+    location [string] :
+
+  message_to_it_is_an_error [test] :
+    description [string] : Sending it a message reports an error that says what to do instead.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      eval 'abc'
+      check it for starts_with? ( 'a' )
+      eval ^^.err_fired = true
+      assert "expected check it for ... to be an error"
+
+      eval ^^.error_data.message = "it isn't an object and can't be sent messages; put it into an object first (put it into x)."
+      assert "expected the error to say to put it into an object first"
+
+  put_into_it_is_an_error [test] :
+    description [string] : Putting a value into it is an error.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      put 'x' into it
+      eval ^^.err_fired = true
+      assert "expected put into it to be an error"
+
+  put_it_into_an_object_works [test] :
+    description [string] : The workaround: put it into an object, then send that object the message.
+    on_test [script] :
+      put false into ^^.err_fired
+      eval 'abc'
+      put it into ^^.s
+      check ^^.s for starts_with? ( 'a' )
+      assert "expected the message to work on the object"
+
+      eval ^^.err_fired = false
+      assert "expected no error"
+
+#
+# The it rule: a command that works out a value puts it in it; when
+# something goes wrong, it is false.
+#
+
+tests.lang.it_rule [can] :
+
+  err_fired [bool] : false
+  s [string] :
+  kept [string] : keep me
+
+  on_error [script] :
+    put true into ^.err_fired
+
+  failed_put_sets_it_false [test] :
+    description [string] : A put whose value can't be worked out sets it to false and keeps the target.
+    expect_errors [bool] : true
+    on_test [script] :
+      put false into ^^.err_fired
+      eval 'before'
+      put ^^.no_such_value into ^^.kept
+      eval it = false
+      assert "expected it to be false after a failed put"
+
+      eval ^^.kept = 'keep me'
+      assert "expected the target to keep its value"
+
+      eval ^^.err_fired = true
+      assert "expected the failed put to be an error"
+
+  put_into_missing_object_sets_it_false [test] :
+    description [string] : A put into an object that doesn't exist sets it to false.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'before'
+      put 'x' into ^^.no_such_target
+      eval it = false
+      assert "expected it to be false"
+
+  value_messages_set_it [test] :
+    description [string] : A message that changes its own value also puts the new value in it.
+    on_test [script] :
+      put '  padded  ' into ^^.s
+      tell ^^.s to trim
+      eval it = 'padded'
+      assert "expected trim to put the trimmed string in it"
+
+      put 'a b' into ^^.s
+      tell ^^.s to format_for_html
+      eval it = 'a b'
+      assert "expected format_for_html to put the result in it"
+
+  failed_function_sets_it_false [test] :
+    description [string] : A function whose on_invoke fails sets it to false.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'before'
+      invoke ^^.failing
+      eval it = false
+      assert "expected it to be false after a failed invoke"
+
+  failing [ƒ] :
+    params [can] :
+    on_invoke [script] :
+      put 1 into no.such.object
+    result [int] :
+
+  message_to_missing_object_sets_it_false [test] :
+    description [string] : A message that can't be delivered leaves no stale value in it.
+    expect_errors [bool] : true
+    on_test [script] :
+      eval 'stale'
+      tell ^^.no_such_obj to get_parent
+      eval it = false
+      assert "expected it to be false after a message to a missing object"
+
+      eval 'stale'
+      tell ^^.s to no_such_msg
+      eval it = false
+      assert "expected it to be false after a message the object doesn't take"
+
+      eval 'stale'
+      run ^^.no_such_obj
+      eval it = false
+      assert "expected it to be false after running a missing object"

data/test.gloo/lang/naming.test.gloo

@@ -14,6 +14,14 @@ tests.lang.naming [can] :
   string [string] : a type keyword as a name
   put [string] : a verb keyword as a name
 
+  # A fixture with a deliberately nameless object, loaded inside its
+  # test so the syntax error it reports belongs to that test.
+  nameless_file [file] : /tmp/gloo_naming_test.gloo
+  nameless_src [text] : BEGIN
+naming_fixture [container] :
+  [string] : no name given
+END
+
   first_of_a_duplicate_name_wins [test] :
     description [string] : when two siblings share a name, the path always reaches the first.
     on_test [script] :
@@ -40,3 +48,16 @@ tests.lang.naming [can] :
 
       eval ^^.put = 'a verb keyword as a name'
       assert "expected a verb keyword to be usable as a name"
+
+  declaration_with_no_name_gets_a_placeholder [test] :
+    description [string] : a declaration with no name loads under the placeholder name unnamed_1.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.nameless_file to write ( ^^.nameless_src )
+      load /tmp/gloo_naming_test.gloo
+      eval naming_fixture.unnamed_1 = 'no name given'
+      assert "expected the nameless object to be reached as unnamed_1"
+
+      tell naming_fixture to unload
+      tell ^^.nameless_file to delete
+

data/test.gloo/lang/ops.test.gloo

@@ -4,6 +4,10 @@
 
 tests.lang.ops [can] :
 
+  first [string] : Ada
+  last [string] : Lovelace
+  full [string] :
+
   confirm_eq_ops [test] :
     description [string] : Confirm equality operations.
     on_test [script] :
@@ -75,3 +79,29 @@ tests.lang.ops [can] :
 
       eval 1 <= 1
       assert "expected 1 <= 1"
+
+  confirm_and_joins [test] :
+    description [string] : and joins values, the same as +.
+    on_test [script] :
+      put ^^.first and ' ' and ^^.last into ^^.full
+      eval ^^.full = 'Ada Lovelace'
+      assert "expected first and ' ' and last to be 'Ada Lovelace'"
+
+      eval 2 and 3 = 5
+      assert "expected 2 and 3 to be 5"
+
+  confirm_join_without_operator [test] :
+    description [string] : Values side by side with no operator between them are joined.
+    on_test [script] :
+      put 'hello ' 'world' into ^^.full
+      eval ^^.full = 'hello world'
+      assert "expected 'hello ' 'world' to be 'hello world'"
+
+      put ^^.first ' ' ^^.last into ^^.full
+      eval ^^.full = 'Ada Lovelace'
+      assert "expected first ' ' last to be 'Ada Lovelace'"
+
+      put 'a' 'b' + 'c' and 'd' into ^^.full
+      eval ^^.full = 'abcd'
+      assert "expected no operator, + and and to mix"
+

data/test.gloo/math/div.test.gloo

@@ -28,8 +28,8 @@ tests.math.div [can] :
       eval 10.5 / 5 = 2.1
       assert 'expected 10.5 / 5 = 2.1'
 
-      eval 100.5 / 200.5 = 0.5
-      assert 'expected 100.5 / 200.5 = 0.5'
+      eval 100.5 / 201 = 0.5
+      assert 'expected 100.5 / 201 = 0.5'
 
       eval 1.5 / 10.5 = 0.1
       refute 'expected 1.5 / 10.5 != 0.1'