gloo 6.7.2 → 7.0

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/lang/declaration.test.gloo

@@ -0,0 +1,27 @@
+#
+# Declaration syntax tests
+#
+
+tests.lang.declaration [can] :
+
+  # Deliberately missing the ']' after its type: loading reports a
+  # syntax error and reads the type as 'int' anyway.
+  unclosed [int : 7
+
+  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.
+    on_test [script] :
+      eval ^^.unclosed = 7
+      assert "expected the value 7"
+
+      put '12' into ^^.unclosed
+      eval ^^.unclosed = 12
+      assert "expected it to still be an integer"
+
+  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,6 +20,8 @@ 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.
@@ -59,3 +61,61 @@ 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.
+    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.
+    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).
+    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.
+    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.
+    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,139 @@
+#
+# 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.
+    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.
+    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.
+    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.
+    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/it.test.gloo

@@ -37,3 +37,136 @@ 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.
+    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.
+    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.
+    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.
+    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.
+    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.
+    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,10 @@ tests.lang.naming [can] :
   string [string] : a type keyword as a name
   put [string] : a verb keyword as a name
 
+  # Deliberately has no name: loading reports a syntax error and
+  # creates it as unnamed_1.
+  [string] : no name given
+
   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 +44,10 @@ 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.
+    on_test [script] :
+      eval ^^.unnamed_1 = 'no name given'
+      assert "expected the nameless object to be reached as unnamed_1"
+

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/objs/can.test.gloo

@@ -43,3 +43,104 @@ tests.objs.can [can] :
       eval it = 0
       assert "expected it to be 0"
 
+
+#
+# Child value and path messages.
+#
+
+tests.objs.can_child [can] :
+
+  list [can] :
+    x [string] : ex
+    y [integer] : 7
+    book [can] :
+      title [string] : Walden
+
+  empty [can] :
+  path [string] :
+  ptr [alias] :
+  slot [alias] :
+  idx [integer] : 0
+  n [integer] : 0
+  found [integer] : 0
+  picked [can] :
+
+  # Pick distinct random children: a random index, skipped if already used.
+  pick_distinct [repeat] :
+    times [integer] : 200
+    index [integer] : 0
+    do [script] :
+      tell tests.objs.can_child.idx to randomize ( tests.objs.can_child.n )
+      check tests.objs.can_child.picked for child_exists ( tests.objs.can_child.idx )
+      unless it do tell tests.objs.can_child.mark to run
+
+  mark [script] :
+    put 'tests.objs.can_child.picked.' + tests.objs.can_child.idx into tests.objs.can_child.slot*
+    create tests.objs.can_child.slot* as integer
+    put tests.objs.can_child.found + 1 into tests.objs.can_child.found
+
+  value_at [test] :
+    description [string] : child_value_at gets a simple child's value by 0-based index.
+    on_test [script] :
+      tell ^^.list to child_value_at ( 0 )
+      eval it = 'ex'
+      assert "expected index 0 to be the first child"
+
+      tell ^^.list to child_value_at ( 1 )
+      eval it = 7
+      assert "expected index 1 to be the second child"
+
+  value_at_container_child [test] :
+    description [string] : child_value_at on a container child is an error, and it is false.
+    on_test [script] :
+      tell ^^.list to child_value_at ( 2 )
+      eval it = false
+      assert "expected false for a container child"
+
+  path_at_alias [test] :
+    description [string] : child_path_at into an alias reaches a container child's fields.
+    on_test [script] :
+      tell ^^.list to child_path_at ( 2 )
+      put it into ^^.path
+      eval ^^.path = 'tests.objs.can_child.list.book'
+      assert "expected the path from root"
+
+      put ^^.path into ^^.ptr*
+      eval ^^.ptr.title = 'Walden'
+      assert "expected to read the field through the alias"
+
+  out_of_range [test] :
+    description [string] : An out-of-range index is an error, and it is false.
+    on_test [script] :
+      tell ^^.list to child_path_at ( 3 )
+      eval it = false
+      assert "expected false for index 3 of 3 children"
+
+  random_path [test] :
+    description [string] : random_child_path gives the path of one of the children.
+    on_test [script] :
+      tell ^^.list to random_child_path
+      put it into ^^.path
+      check ^^.path for starts_with? ( 'tests.objs.can_child.list.' )
+      assert "expected a child's path"
+
+  random_empty [test] :
+    description [string] : random_child_value on an empty container is an error, and it is false.
+    on_test [script] :
+      tell ^^.empty to random_child_value
+      eval it = false
+      assert "expected false for an empty container"
+
+  distinct_random_picks [test] :
+    description [string] : A random index plus a picked container gives distinct picks.
+    on_test [script] :
+      tell ^^.list to count
+      put it into ^^.n
+      tell ^^.pick_distinct to run
+
+      tell ^^.picked to count
+      eval it = 3
+      assert "expected every child picked exactly once"
+
+      eval ^^.found = 3
+      assert "expected no index to be picked twice"

data/test.gloo/objs/string.test.gloo

@@ -52,6 +52,30 @@ tests.objs.string [can] :
       eval ^^.s = 'one two three'
       assert "expected split to leave the string unchanged"
 
+  index_of [test] :
+    description [string] : Find the position of a substring
+    on_test [script] :
+      put 'one two three' into ^^.s
+      tell ^^.s to index_of ('two')
+      eval it = 4
+      assert "expected index_of ('two') to equal 4"
+      tell ^^.s to index_of ('four')
+      eval it = -1
+      assert "expected index_of a missing needle to equal -1"
+      eval ^^.s = 'one two three'
+      assert "expected index_of to leave the string unchanged"
+
+  index_of_from [test] :
+    description [string] : Find a substring at or after a start position
+    on_test [script] :
+      put '![[123.png]] and ]]' into ^^.s
+      tell ^^.s to index_of (']]' 3)
+      eval it = 10
+      assert "expected index_of (']]' 3) to equal 10"
+      tell ^^.s to index_of (']]' 11)
+      eval it = 17
+      assert "expected index_of (']]' 11) to equal 17"
+
   splitl [test] :
     description [string] : Get the substring to the left of an index
     on_test [script] :