gloo 7.1.2 → 7.2

data/lib/gloo/verbs/move.rb

@@ -13,9 +13,15 @@ module Gloo
       TO = 'to'.freeze
       MISSING_SRC_ERR = 'Object to move was not specified!'.freeze
       MISSING_DST_ERR = "'Move' must include 'to' parent object!".freeze
+      NAME_TAKEN_ERR = "Could not move '%s': '%s' already has a child named '%s'.".freeze
+      INSIDE_ITSELF_ERR = "Could not move '%s': it can't go inside itself.".freeze
 
       #
       # Run the verb.
+      # A name is unique in its container, so an object can't move into
+      # one that already has a child with its name; nor can it move
+      # inside itself. Moving it to the parent it's already in does
+      # nothing.
       #
       def run
         dst = lookup_dst
@@ -23,6 +29,9 @@ module Gloo
 
         o = lookup_obj
         return unless o
+        return if dst.equal?( o.parent )
+        return refuse( format( INSIDE_ITSELF_ERR, o.pn ) ) if inside?( dst, o )
+        return refuse( format( NAME_TAKEN_ERR, o.pn, dst.pn, o.name ) ) if dst.contains_child?( o.name )
 
         o.parent.remove_child o
         dst.add_child o
@@ -48,6 +57,28 @@ module Gloo
 
       private
 
+      #
+      # Report why the object can't be moved; nothing moves, and it is
+      # false.
+      #
+      def refuse( msg )
+        @engine.err msg
+        @engine.heap.it.set_to false
+      end
+
+      #
+      # Is dst the object itself, or somewhere under it?
+      #
+      def inside?( dst, obj )
+        o = dst
+        while o
+          return true if o.equal?( obj )
+
+          o = o.parent
+        end
+        return false
+      end
+
       #
       # Lookup the object that we're moving.
       #
@@ -97,18 +128,26 @@ module Gloo
         {
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
-          :description => 'Move an object to a new parent.',
+          :description => 'Move an object to a new parent. A name is unique ' \
+            'in its container, so the new parent must not already have a ' \
+            'child with the same name.',
           :syntax => [ 'move {path.to.object} to {new.parent}' ],
           :parameters => [
             '{path.to.object} — The object that we want to move.',
             '{new.parent} — The new location for the object.'
           ],
-          :result => 'The object will now be in the new location.',
+          :result => 'The object will now be in the new location. Moving it ' \
+            'to the parent it is already in does nothing. A pure action: it ' \
+            'is left alone, unless the move is refused.',
           :errors => [
             "#{MISSING_SRC_ERR} The {path.to.object} is not specified.",
             "Object '{path.to.object}' was not found. — The {path.to.object} cannot be resolved.",
             "#{MISSING_DST_ERR} The {new.parent} is not specified.",
-            "Object '{new.parent}' was not found. — The {new.parent} cannot be resolved."
+            "Object '{new.parent}' was not found. — The {new.parent} cannot be resolved.",
+            "#{format( NAME_TAKEN_ERR, '{path.to.object}', '{new.parent}', '{name}' )} — " \
+              'The new parent already has a child with that name. Nothing moves, and it is false.',
+            "#{format( INSIDE_ITSELF_ERR, '{path.to.object}' )} — The new parent is the " \
+              'object itself or something under it. Nothing moves, and it is false.'
           ],
           :examples => <<~EXAMPLES.strip
             can [can] :

data/lib/gloo/verbs/save.rb

@@ -91,8 +91,13 @@ module Gloo
           ],
           :parameters => [
             '{path.to.object} — Name of the object to save.',
-            '{path} — Where to save it, relative to the project root ' \
-              '(.gloo appended if omitted). Registers the mapping, so ' \
+            '{path} — Where to save it: a full path, one starting ' \
+              'with ~, or a relative name (.gloo appended if omitted). ' \
+              'A relative name goes in the first place a relative load ' \
+              'looks: the app folder in App mode; otherwise next to the ' \
+              "saving script's file (the projects folder for a script " \
+              'that did not come from a file), or the working folder for ' \
+              'a command typed at the prompt. Registers the mapping, so ' \
               'a later bare save includes it.',
             '( {expression} ) — Instead of a literal path, an expression ' \
               'in parentheses: it is worked out and its value is used as ' \
@@ -105,7 +110,14 @@ module Gloo
             'A declaration you never touched comes back byte-for-byte. ' \
             'An object counts as changed only when its value is set or ' \
             'it is created, moved, or deleted (its doc comment goes with ' \
-            'it); changes to its children do not change it. ' \
+            'it); changes to its children do not change it. A changed ' \
+            'declaration keeps its name, type and spacing; only its ' \
+            'value is written again. A new object goes after the last ' \
+            "child of its parent's first declaration, in the file's " \
+            'indentation and type spellings. An object declared on more ' \
+            'than one line has its value on the first: a change rewrites ' \
+            'only that line, and deleting or moving it takes all its ' \
+            'lines. ' \
             'With a path, the object also stops being declared in its ' \
             'old file (if it had one) -- both files are rewritten ' \
             'together.',
@@ -122,7 +134,17 @@ module Gloo
               'container from nested-container shorthand; extract a ' \
               'child that does, or a shallower ancestor that does.'
           ],
-          :notes => 'An object can also be told to save itself: ' \
+          :notes => 'A value that cannot be written exactly (a block ' \
+            'value with no final line break, a line that is just END, ' \
+            'bytes that are not UTF-8) is written as closely as possible, ' \
+            "with a warning: Could not save '{path}' exactly: {why}. A " \
+            'changed script body loses the comments and blank lines ' \
+            'inside it. A new top-level object has no file yet: a bare ' \
+            'save leaves it out and warns (Not saved (no file yet): ' \
+            '{name}.); save {name} gives it a file of its own, named ' \
+            'after it and placed the same way as a relative path. ' \
+            'See doc verbs, Load & Save. ' \
+            'An object can also be told to save itself: ' \
             '`tell my_obj to save`. When several files contribute to ' \
             'one container (the namespace pattern), each file save only ' \
             "rewrites that file's own declarations. Extraction (save " \

data/test.gloo/app/exit_status.test.gloo

@@ -0,0 +1,34 @@
+#
+# Exit status of a script run.
+# `gloo file.gloo` exits 1 if anything went wrong at any point in the
+# run, not just on its last line. The engine running these tests was
+# started in Test mode, so the check runs gloo again with [system],
+# on a fixture beside this file.
+#
+
+tests.app.exit_status [can] :
+
+  # The interpreter and the fixture, both found from source_dir.
+  run_rb [string] : /../../lib/run.rb
+  fixture [string] : /fixtures/exit_after_error.gloo
+  quiet [string] : --quiet
+  # The fixture's error output isn't part of these tests' output.
+  discard [string] : > /dev/null 2>&1
+  where [string] :
+
+  run_gloo [system] :
+    command [string] :
+    get_output [bool] : false
+    result [bool] :
+
+  error_then_success_exits_1 [test] :
+    description [string] : A run with an error on an earlier line exits non-zero, though its last line works.
+    on_test [script] :
+      check ^^ for source_dir
+      put it into ^^.where
+      # Paths are quoted in case the folder has spaces.
+      put "ruby '" ^^.where ^^.run_rb "' " ^^.quiet " '" ^^.where ^^.fixture "' " ^^.discard into ^^.run_gloo.command
+      tell ^^.run_gloo to run
+      # result is false when the command exits non-zero.
+      eval ^^.run_gloo.result
+      refute "expected the run to exit non-zero"

data/test.gloo/app/fixtures/exit_after_error.gloo

@@ -0,0 +1,9 @@
+#
+# Run by exit_status.test.gloo as `gloo` would run it: an error, then
+# a line that works. The run must still exit 1.
+#
+a [can] :
+  n [int] : 0
+  on_load [script] :
+    show no.such.object
+    put 1 into a.n

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

@@ -41,3 +41,39 @@ END
     on_test [script] :
       eval ^^.closed_then_colon = 8
       assert "expected the value 8"
+
+  # A fixture beside this file whose lines mix tabs and spaces, on one
+  # line and from line to line: a tab counts as two spaces.
+  mixed_indent_path [string] : /fixtures/mixed_indent.gloo
+  where [string] :
+
+  a_tab_and_spaces_on_one_line_add_up [test] :
+    description [string] : a tab plus two spaces is two levels deep, in either order.
+    on_test [script] :
+      check ^^ for source_dir
+      put it into ^^.where
+      load ( ^^.where ^^.mixed_indent_path )
+      tell mixed_indent_fixture.a to count
+      eval it = 2
+      assert "expected x and y under a"
+      eval mixed_indent_fixture.b = 3
+      assert "expected b beside a"
+      tell mixed_indent_fixture to unload
+
+  # Spaces just inside the brackets are allowed.
+  spaced_int [ int ] : 5
+  spaced_after [int ]: 6
+  spaced_text [text ] : BEGIN
+one
+END
+
+  spaces_inside_the_brackets_are_allowed [test] :
+    description [string] : a space just inside a type's brackets doesn't change the type.
+    on_test [script] :
+      eval ^^.spaced_int = 5
+      assert "expected [ int ] to be an integer 5"
+      eval ^^.spaced_after + 1 = 7
+      assert "expected [int ]: to be an integer 6"
+      check ^^.spaced_text for starts_with? ( 'one' )
+      assert "expected [text ] to read its block"
+

data/test.gloo/lang/fixtures/mixed_indent.gloo

@@ -0,0 +1,5 @@
+mixed_indent_fixture [can] :
+	a [can] :
+	  x [int] : 1
+  	y [int] : 2
+	b [int] : 3

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

@@ -4,9 +4,6 @@
 
 tests.lang.naming [can] :
 
-  dup [string] : first
-  dup [string] : second
-
   Alpha [string] : mixed case
 
   1 [string] : numeric name
@@ -18,9 +15,24 @@ tests.lang.naming [can] :
   # test so the syntax error it reports belongs to that test.
   nameless_file [file] :
 
+  # A fixture that declares one name twice, loaded inside its tests so
+  # the warning about the ignored value belongs to them.
+  dup_file [file] :
+
   # Scratch files live in the gloo tmp folder ($.gloo_tmp).
   on_load [script] :
     put $.gloo_tmp '/gloo_naming_test.gloo' into ^.nameless_file
+    put $.gloo_tmp '/gloo_naming_dup_test.gloo' into ^.dup_file
+
+  dup_src [text] : BEGIN
+dup_fixture [container] :
+  dup [string] : first
+  dup [string] : second
+  box [container] :
+    x [string] : ex
+  box [container] :
+    y [string] : why
+END
 
   nameless_src [text] : BEGIN
 naming_fixture [container] :
@@ -28,10 +40,36 @@ naming_fixture [container] :
 END
 
   first_of_a_duplicate_name_wins [test] :
-    description [string] : when two siblings share a name, the path always reaches the first.
+    description [string] : a second declaration of a name is the same object; the first value wins.
+    expect_errors [bool] : true
+    on_test [script] :
+      tell ^^.dup_file to write ( ^^.dup_src )
+      load ( ^^.dup_file )
+      eval dup_fixture.dup = 'first'
+      assert "expected the first value to win"
+
+      tell dup_fixture to count
+      eval it = 2
+      assert "expected one 'dup' and one 'box', not four objects"
+
+      tell dup_fixture to unload
+      tell ^^.dup_file to delete
+
+  a_container_declared_twice_merges [test] :
+    description [string] : a container declared twice is one container with the children of both.
+    expect_errors [bool] : true
     on_test [script] :
-      eval ^^.dup = 'first'
-      assert "expected the first 'dup' to be the one reached"
+      tell ^^.dup_file to write ( ^^.dup_src )
+      load ( ^^.dup_file )
+      tell dup_fixture.box to count
+      eval it = 2
+      assert "expected x and y in the one box"
+
+      eval dup_fixture.box.y = 'why'
+      assert "expected the second declaration's child to be there"
+
+      tell dup_fixture to unload
+      tell ^^.dup_file to delete
 
   path_lookup_is_case_insensitive [test] :
     description [string] : a pathname segment matches a name regardless of case.

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

@@ -8,7 +8,7 @@ tests.verbs.break [can] :
 
   s [script] :
     if ^.b  then break
-        
+
     # Should not get here
     put false into ^.b
 
@@ -19,16 +19,27 @@ tests.verbs.break [can] :
       eval ^^.b
       assert "expected b to be true"
 
-  # Loops whose do script breaks on its second pass.
+  # The last error, for the break loop errors.
+  on_error [script] :
+  error_data [can] :
+    message [string] :
+
+  not_in_a_loop [string] : Could not break loop: not in a loop.
+
+  # Loops whose do script breaks on one pass: skip_on for a plain
+  # break, end_on for break loop (0 never breaks).
   passes [int] : 0
   after [int] : 0
+  skip_on [int] : 0
+  end_on [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
+      if tests.verbs.break.passes = tests.verbs.break.skip_on then break
+      if tests.verbs.break.passes = tests.verbs.break.end_on then break loop
       put tests.verbs.break.after + 1 into tests.verbs.break.after
 
   kids [can] :
@@ -41,14 +52,15 @@ tests.verbs.break [can] :
     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
+      if tests.verbs.break.passes = tests.verbs.break.skip_on then break
+      if tests.verbs.break.passes = tests.verbs.break.end_on then break loop
       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
+      if tests.verbs.break.inner.index = 1 then break loop
       put tests.verbs.break.after + 1 into tests.verbs.break.after
 
   outer [repeat] :
@@ -57,30 +69,111 @@ tests.verbs.break [can] :
     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.
+  # The form the apps use to skip an item: unless ... do break.
+  skipped [string] :
+  skip_b [each] :
+    child [alias] :
+    in [alias] : tests.verbs.break.kids
+    do [script] :
+      check tests.verbs.break.skip_b.child for starts_with?( 'b' )
+      unless it = false do break
+      put tests.verbs.break.skipped + tests.verbs.break.skip_b.child into tests.verbs.break.skipped
+
+  # break loop is only valid directly in a loop's do script.
+  lone [script] :
+    break loop
+
+  loop_helper [script] :
+    break loop
+
+  via_loop [repeat] :
+    times [int] : 2
+    index [int] :
+    do [script] :
+      put tests.verbs.break.passes + 1 into tests.verbs.break.passes
+      run tests.verbs.break.loop_helper
+
+  break_skips_the_rest_of_a_repeat_pass [test] :
+    description [string] : break in a repeat's do script skips to the next pass.
     on_test [script] :
       put 0 into ^^.passes
       put 0 into ^^.after
+      put 0 into ^^.end_on
+      put 2 into ^^.skip_on
+      tell ^^.rep to run
+      eval ^^.passes = 4
+      assert "expected every pass to run"
+      eval ^^.after = 3
+      assert "expected only the pass that broke to stop early"
+
+  break_skips_the_rest_of_an_each_pass [test] :
+    description [string] : break in an each's do script skips to the next child.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      put 0 into ^^.end_on
+      put 2 into ^^.skip_on
+      tell ^^.each_kid to run
+      eval ^^.after = 2
+      assert "expected every child but the one that broke to get past it"
+
+  unless_do_break_skips_an_item [test] :
+    description [string] : unless ... do break in an each skips that item, as the apps use it.
+    on_test [script] :
+      put '' into ^^.skipped
+      tell ^^.skip_b to run
+      eval ^^.skipped = 'ac'
+      assert "expected b to be skipped and c still reached"
+
+  break_loop_ends_a_repeat [test] :
+    description [string] : break loop in a repeat's do script ends the loop.
+    on_test [script] :
+      put 0 into ^^.passes
+      put 0 into ^^.after
+      put 0 into ^^.skip_on
+      put 2 into ^^.end_on
       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.
+  break_loop_ends_an_each [test] :
+    description [string] : break loop in an each's do script ends the loop.
     on_test [script] :
       put 0 into ^^.passes
       put 0 into ^^.after
+      put 0 into ^^.skip_on
+      put 2 into ^^.end_on
       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.
+  break_loop_ends_only_the_inner_loop [test] :
+    description [string] : break loop 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"
+
+  break_loop_outside_a_loop_is_an_error [test] :
+    description [string] : break loop in a script that isn't a loop's do is an error.
+    expect_errors [bool] : true
+    on_test [script] :
+      put '' into ^^.error_data.message
+      run ^^.lone
+      eval ^^.error_data.message = ^^.not_in_a_loop
+      assert "expected the not-in-a-loop error"
+
+  break_loop_in_a_helper_is_an_error [test] :
+    description [string] : break loop in a script the do runs is an error, and the loop goes on.
+    expect_errors [bool] : true
+    on_test [script] :
+      put '' into ^^.error_data.message
+      put 0 into ^^.passes
+      tell ^^.via_loop to run
+      eval ^^.error_data.message = ^^.not_in_a_loop
+      assert "expected the not-in-a-loop error"
+      eval ^^.passes = 2
+      assert "expected the loop to go on"

data/test.gloo/verbs/fixtures/load_beside.gloo

@@ -0,0 +1,6 @@
+#
+# Loaded by load.test.gloo with a plain relative name, from the
+# folder beside that test file. Not a test file itself.
+#
+load_beside_demo [can] :
+  s [string] : beside

data/test.gloo/verbs/fixtures/lossless_text.gloo

@@ -0,0 +1,7 @@
+lossless_text [can] :
+  log [text] : BEGIN
+Started.
+END
+  entry [text] : BEGIN
+Saved.
+END

data/test.gloo/verbs/fixtures/lossless_text_saved.gloo

@@ -0,0 +1,9 @@
+lossless_text [can] :
+  log [text] : BEGIN
+Started.
+Saved.
+Saved.
+  END
+  entry [text] : BEGIN
+Saved.
+END

data/test.gloo/verbs/load.test.gloo

@@ -172,3 +172,21 @@ END
       assert "expected the full path without .gloo to load"
       tell computed_demo to unload
       tell ^^.computed_f to delete
+
+  # A relative name looks next to the loading file first; these scripts
+  # are declared in this file, so fixtures/ is the folder beside it.
+  load_a_file_beside_this_one [test] :
+    description [string] : A relative load finds a file next to the file the script came from.
+    on_test [script] :
+      load fixtures/load_beside
+      eval load_beside_demo.s = 'beside'
+      assert "expected fixtures/load_beside.gloo to load from beside this file"
+      tell load_beside_demo to unload
+
+  load_a_prefix_beside_this_one [test] :
+    description [string] : A relative wildcard with a file name prefix finds the files next to the loading file.
+    on_test [script] :
+      load fixtures/load_beside*
+      eval load_beside_demo.s = 'beside'
+      assert "expected fixtures/load_beside*.gloo to load from beside this file"
+      tell load_beside_demo to unload

data/test.gloo/verbs/move.test.gloo

@@ -16,3 +16,42 @@ tests.verbs.move [can] :
       assert "expected a to be in t"
       exists? instance tests.verbs.move.c.a
       refute "expected a not to be in c"
+
+  # A name is unique in its container: a move onto a taken name, or
+  # inside itself, is refused.
+  taken [container] :
+    a [string] : moving
+  dst [container] :
+    a [string] : already here
+  outer [container] :
+    inner [container] :
+  msg [string] :
+
+  on_error [script] :
+  error_data [can] :
+    message [string] :
+
+  moving_onto_a_taken_name_is_refused [test] :
+    description [string] : A move into a container with a child of the same name is an error; nothing moves.
+    expect_errors [bool] : true
+    on_test [script] :
+      move ^^.taken.a to ^^.dst
+      eval it = false
+      assert "expected it to be false"
+      eval ^^.dst.a = 'already here'
+      assert "expected the child already there to be untouched"
+      exists? instance ^^.taken.a
+      assert "expected the object not to have moved"
+      put ^^.error_data.message into ^^.msg
+      check ^^.msg for starts_with? ( 'Could not move' )
+      assert "expected a could-not-move error"
+
+  moving_inside_itself_is_refused [test] :
+    description [string] : A move into the object's own child is an error; nothing moves.
+    expect_errors [bool] : true
+    on_test [script] :
+      move ^^.outer to ^^.outer.inner
+      eval it = false
+      assert "expected it to be false"
+      exists? instance ^^.outer.inner
+      assert "expected outer to still be in place"