gloo 7.1.2 → 7.2

data/lib/gloo/persist/persist_man.rb

@@ -14,6 +14,7 @@ module Gloo
 
       PATH_EXISTS_ERR = 'Will not overwrite a file not already saved there: '.freeze
       RELOAD_DIRTY_WARNING = 'Reloading will discard unsaved changes in: '.freeze
+      NOT_SAVED_WARNING = 'Not saved (no file yet): '.freeze
 
       #
       # Constructor for the persistence manager.
@@ -33,10 +34,25 @@ module Gloo
       end
 
       #
-      # Save every open file.
+      # Save every open file. A new top-level object has no file to go
+      # in, so it isn't saved; warn, naming each one.
       #
       def save_all
         save_batch( @maps )
+        warn_unsaved_roots
+      end
+
+      #
+      # Warn about top-level objects no file declares (made since load),
+      # which a bare save leaves out.
+      #
+      def warn_unsaved_roots
+        index = Gloo::Persist::SaveIndex.new( @engine, @maps )
+        names = @engine.heap.root.children.reject { |o| index.placed?( o ) }.map( &:name )
+        return if names.empty?
+
+        how = names.size == 1 ? "save #{names.first}" : 'save {name} for each'
+        @engine.warn "#{NOT_SAVED_WARNING}#{names.join( ', ' )}. Use #{how}."
       end
 
       #
@@ -50,7 +66,7 @@ module Gloo
         return unless obj
 
         fs_list = find_file_storages( obj )
-        return save_new( obj, @mech.resolve_save_path( root_of( obj ).name ) ) if fs_list.empty?
+        return save_new( obj, @mech.resolve_save_path( root_of( obj ).name, save_folder ) ) if fs_list.empty?
 
         @engine.event_manager.on_save obj
         save_batch( fs_list )
@@ -72,7 +88,7 @@ module Gloo
         obj = resolve_for_save( name )
         return unless obj
 
-        pn = @mech.resolve_save_path( path )
+        pn = @mech.resolve_save_path( path, save_folder )
         mapped = @maps.find { |fs| fs.pn == pn }
         return save_mapped( obj, mapped, pn ) if mapped
         return @engine.err( "#{PATH_EXISTS_ERR}#{pn}" ) if @mech.exist?( pn )
@@ -87,8 +103,13 @@ module Gloo
       # a missing/unresolvable file is reported via engine.err rather
       # than failing silently.
       #
-      def load( name )
-        pns = get_full_path_names name
+      # A relative name is looked for in the given folders, in order
+      # (the load verb passes search_folders). Without them (a file
+      # named on the command line, the app's start file) it's looked
+      # for as given, then in the project folder and gloo home.
+      #
+      def load( name, folders = nil )
+        pns = get_full_path_names( name, folders )
         if pns.nil? || pns.empty?
           @engine.err( Gloo::Core::NotFound.file( name ) ) unless name.to_s.strip.empty?
           return false
@@ -212,18 +233,63 @@ module Gloo
 
 
       #
-      # Get the full path and name of the file.
+      # Get the full path and name of the file, looking for a relative
+      # name in the given folders (see load).
       #
-      def get_full_path_names( name )
+      def get_full_path_names( name, folders = nil )
         return nil if name.strip.empty?
 
         if name.strip[ -1 ] == '*'
-          return @mech.get_all_files_in( name[ 0..-2 ] )
+          return @mech.get_all_files_in( name[ 0..-2 ], folders )
         else
-          return @mech.expand( name )
+          return @mech.expand( name, folders )
         end
       end
 
+      #
+      # Where the load verb looks for a relative name, in order.
+      # In App mode the app folder comes first, so an app's names
+      # mean the same thing in every one of its files. Otherwise the
+      # folder next to the loading file comes first, then the projects
+      # folder (the project_path setting). The gloo home is last.
+      #
+      def search_folders
+        near = near_folder
+        project = @engine.settings.project_path
+        home = @engine.settings.user_root
+        folders = if @engine.mode == Gloo::App::Mode::APP
+                    [ project, near, home ]
+                  else
+                    [ near, project, home ]
+                  end
+        return folders.compact.uniq
+      end
+
+      #
+      # Where a new file saved with a relative name goes: the first
+      # place a relative load looks (see search_folders). That's the
+      # app folder in App mode; otherwise next to the saving script's
+      # file, or the working folder for a command typed at the prompt,
+      # or the projects folder for a script that didn't come from a file.
+      #
+      def save_folder
+        return search_folders.first
+      end
+
+      #
+      # The folder "next to" the line now running: the folder of the
+      # file the running script came from (the same folder source_dir
+      # gives). A command typed at the prompt has no file, so it's the
+      # working folder. A script that didn't come from a file has none.
+      #
+      def near_folder
+        script = @engine.exec_env.running_script
+        return Dir.pwd unless script
+
+        path = source_file_of( script.obj )
+        return path ? File.dirname( path ) : nil
+      end
+
       #
       # Check to see if a given path name refers to a gloo object file.
       #
@@ -271,39 +337,55 @@ module Gloo
       end
 
       #
-      # Save a set of files as one batch so a multi-file namespace
-      # round-trips: each file only rewrites the declarations its own
-      # SourceDoc holds and leaves other files' declarations alone; a
-      # brand-new object no file owns is written once, by the first file
-      # in the batch to reach it.
+      # Save a set of files as one batch, with one index of what every
+      # loaded file declares: each file writes back its own declarations
+      # and leaves other files' alone, and a new or moved object is
+      # written once, by the file its parent's first declaration is in.
+      # A file an object moved into is saved too, so the object isn't
+      # dropped from one file without being written to another. Each
+      # file then keeps a source document for what was written.
       #
       def save_batch( files )
-        claimed = {}.compare_by_identity
+        index = Gloo::Persist::SaveIndex.new( @engine, @maps )
+        files = with_move_targets( files, index )
+        saved = files.map { |fs| [ fs, fs.save( :index => index ) ] }
+        saved.each { |fs, doc| fs.saved( doc ) }
+      end
+
+      #
+      # The files to save, plus any file an object declared in one of
+      # them has moved into.
+      #
+      def with_move_targets( files, index )
+        all = files.dup
         files.each do |fs|
-          fs.save( :others => owned_elsewhere( fs ), :claimed => claimed )
+          next unless fs.source_doc
+
+          fs.source_doc.obj_nodes.each do |node|
+            next if index.standing?( node ) || !attached?( node.obj )
+
+            target, = index.writer_for( node.obj.parent )
+            all << target if target && !all.include?( target )
+          end
         end
+        return all
       end
 
       #
-      # Every heap object fs's SourceDoc declares.
+      # Is the object attached to a parent (it was moved, not deleted)?
       #
-      def declared_by( fs )
-        owned = {}.compare_by_identity
-        collect_owned( fs.source_doc&.children, owned )
-        return owned
+      def attached?( obj )
+        return false unless obj&.parent
+
+        return obj.parent.children.any? { |c| c.equal?( obj ) }
       end
 
       #
-      # Every heap object declared by some loaded file's SourceDoc
-      # other than fs.
+      # Every heap object fs's SourceDoc declares.
       #
-      def owned_elsewhere( fs )
+      def declared_by( fs )
         owned = {}.compare_by_identity
-        @maps.each do |other|
-          next if other.equal?( fs )
-
-          collect_owned( other.source_doc&.children, owned )
-        end
+        collect_owned( fs.source_doc&.children, owned )
         return owned
       end
 
@@ -362,7 +444,7 @@ module Gloo
       def save_new( obj, pn )
         @engine.event_manager.on_save obj
         fs = Gloo::Persist::FileStorage.new( @engine, pn, root_of( obj ) )
-        fs.save
+        fs.saved( fs.save )
         @maps << fs
       end
 

data/lib/gloo/persist/save_index.rb

@@ -0,0 +1,211 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# What every loaded file declares, for one save: which declarations
+# name each object (one object can be declared on several lines, in
+# one file or several), which of them still stand, and where an object
+# no declaration places (new, or moved) should be written.
+#
+# A declaration stands if its object is still under the parent it was
+# loaded under, and the declaration it sits under stands too. The
+# first declaration of an object (in load order) holds its value.
+#
+
+module Gloo
+  module Persist
+    class SaveIndex
+
+      #
+      # Index the source documents of the given file storages, in load
+      # order.
+      #
+      def initialize( engine, storages )
+        @engine = engine
+        @entries = {}.compare_by_identity
+        @standing = {}.compare_by_identity
+        @claimed = {}.compare_by_identity
+        @targets = {}.compare_by_identity
+        @in_order = []
+        @implied = {}.compare_by_identity
+        @members = {}.compare_by_identity
+        storages.each do |fs|
+          walk( fs, fs.source_doc.children, true, @engine.heap.root ) if fs.source_doc
+        end
+        find_shorthand_targets
+      end
+
+      #
+      # Does the declaration still stand (it's written back in its
+      # file)?
+      #
+      def standing?( node )
+        return @standing.fetch( node, false )
+      end
+
+      #
+      # Does the declaration hold its object's value (it's the first one
+      # that names the object)?
+      #
+      def holder?( node )
+        first = @entries[ node.obj ]&.first
+        return first ? first[ 1 ].equal?( node ) : true
+      end
+
+      #
+      # The declarations of an object, in load order, as [ fs, node ].
+      #
+      def entries_for( obj )
+        return @entries.fetch( obj, [] )
+      end
+
+      #
+      # Does some standing declaration place the object: its own, or a
+      # dotted one that names it on the way to its object?
+      #
+      def placed?( obj )
+        return declared?( obj ) || @implied.key?( obj )
+      end
+
+      #
+      # Does a standing declaration of the object's own place it?
+      #
+      def declared?( obj )
+        return entries_for( obj ).any? { |_, node| standing?( node ) }
+      end
+
+      #
+      # Where a new or moved child of parent is written:
+      # [ fs, node, nil ] -- under that declaration of parent, after its
+      # last child; [ fs, node, prefix ] -- as a shorthand line after
+      # that dotted declaration, named prefix.child; or nil when no file
+      # takes it (a new root-level object isn't added to a file).
+      #
+      def writer_for( parent )
+        return nil if parent.nil? || parent.root?
+
+        fs, node = entries_for( parent ).find { |_, n| standing?( n ) }
+        return [ fs, node, nil ] if node
+
+        return @targets[ parent ]
+      end
+
+      #
+      # The intermediate containers a dotted declaration writes new
+      # children for, as [ parent, prefix ].
+      #
+      def shorthand_targets( node )
+        return @targets.select { |_, t| t[ 1 ].equal?( node ) }.map { |parent, t| [ parent, t[ 2 ] ] }
+      end
+
+      #
+      # Claim an object for writing in this save; false if a file
+      # already wrote it.
+      #
+      def claim( obj )
+        return false if @claimed.key?( obj )
+
+        @claimed[ obj ] = true
+        return true
+      end
+
+      #
+      # The children of parent that no standing declaration places (new,
+      # or moved in), claimed for writing.
+      #
+      def unplaced_children( parent )
+        return parent.children.select { |c| !placed?( c ) && claim( c ) }
+      end
+
+      private
+
+      #
+      # Record the declarations in a list of source nodes. container is
+      # the object the list's declarations are under (the heap root at
+      # the top of a file).
+      #
+      def walk( fs, nodes, parent_standing, container )
+        nodes.each do |node|
+          next unless node.is_a?( Source::ObjNode )
+
+          stands = parent_standing && stands_alone?( node, container )
+          @standing[ node ] = stands
+          @in_order << [ fs, node ]
+          ( @entries[ node.obj ] ||= [] ) << [ fs, node ] if node.obj
+          walk( fs, node.children, stands, node.obj || container )
+        end
+      end
+
+      #
+      # Is a declaration's object where the declaration puts it: under
+      # its parent as loaded, and -- for a dotted (shorthand) name --
+      # reached from container by that path? A line gloo couldn't make
+      # an object for is always kept.
+      #
+      def stands_alone?( node, container )
+        return true unless node.obj
+        return false unless node.obj.parent.equal?( node.home ) && child_of?( node.obj, node.home )
+
+        segments = node.name.split( '.' )
+        return true if segments.size == 1
+
+        o = node.obj.parent
+        segments[ 0..-2 ].reverse.each do |seg|
+          return false unless o && o.name.casecmp?( seg ) && child_of?( o, o.parent )
+
+          o = o.parent
+        end
+        return o.equal?( container )
+      end
+
+      #
+      # Is child one of parent's children (by identity)? Each parent's
+      # children are gathered once, so a big container stays quick.
+      #
+      def child_of?( child, parent )
+        return false unless parent
+
+        unless @members.key?( parent )
+          set = {}.compare_by_identity
+          parent.children.each { |c| set[ c ] = true }
+          @members[ parent ] = set
+        end
+        return @members[ parent ].key?( child )
+      end
+
+      #
+      # For each container that only exists through dotted names (it has
+      # no declaration of its own), the shorthand line new children go
+      # after: the last one through it, in the first file that has one.
+      #
+      def find_shorthand_targets
+        @in_order.each do |fs, node|
+          next unless node.obj && standing?( node ) && node.name.include?( '.' )
+
+          intermediates( node ).each do |parent, prefix|
+            next if declared?( parent )
+
+            @implied[ parent ] = true
+            target = @targets[ parent ]
+            @targets[ parent ] = [ fs, node, prefix ] if target.nil? || target[ 0 ].equal?( fs )
+          end
+        end
+      end
+
+      #
+      # The containers a dotted declaration names on its way to its
+      # object, as [ container, dotted path to it ].
+      #
+      def intermediates( node )
+        segments = node.name.split( '.' )
+        found = []
+        o = node.obj.parent
+        ( segments.size - 1 ).downto( 1 ) do |i|
+          found.unshift( [ o, segments[ 0, i ].join( '.' ) ] )
+          o = o.parent
+        end
+        return found
+      end
+
+    end
+  end
+end

data/lib/gloo/persist/script_body_collector.rb

@@ -36,15 +36,16 @@ module Gloo
       end
 
       #
-      # One line while a body might be open. line_tabs is its
+      # One line while a body might be open. line is the line as read
+      # (continuations joined), raw its exact source text, line_tabs its
       # indentation (ignored for a blank line, which is always kept).
-      # Returns true if the line was consumed as body content, or
-      # false if it closed the body and still needs to be dispatched
-      # normally by the caller.
+      # Returns true if the line was consumed as body content, or false
+      # if it closed the body and still needs to be dispatched normally
+      # by the caller.
       #
-      def handle_line( line, line_tabs )
+      def handle_line( line, raw, line_tabs )
         if line.strip.empty?
-          @lines << chomped( line )
+          keep( raw )
           return true
         end
 
@@ -53,7 +54,8 @@ module Gloo
           return false
         end
 
-        add_line( line )
+        keep( raw )
+        @obj.add_line( line ) unless line.strip.start_with?( '#' )
         return true
       end
 
@@ -69,14 +71,14 @@ module Gloo
       private
 
       #
-      # Record one real body line: kept verbatim for the source model;
-      # added as a runnable command only if it isn't a comment (a
-      # comment inside a script body is documentation, not something
-      # to execute).
+      # Keep one body line's exact text: on the node's own text, and in
+      # the body's raw value. A comment line is kept but isn't added as a
+      # command (a comment inside a script body is documentation, not
+      # something to execute).
       #
-      def add_line( line )
-        @lines << chomped( line )
-        @obj.add_line( line ) unless line.strip.start_with?( '#' )
+      def keep( raw )
+        @node.raw << raw
+        @lines << raw.chomp( "\n" )
       end
 
       #
@@ -90,13 +92,6 @@ module Gloo
         @obj = nil
       end
 
-      #
-      # A line's raw text with its trailing newline removed.
-      #
-      def chomped( line )
-        return line.chomp( "\n" )
-      end
-
     end
   end
 end

data/lib/gloo/persist/source/blank_node.rb

@@ -13,14 +13,21 @@ module Gloo
         attr_reader :raw
 
         #
-        # Set up a blank line node. raw is the full source line, minus
-        # its trailing newline (may be non-empty if the blank line had
-        # trailing whitespace -- preserved rather than normalized).
+        # Set up a blank line node. raw is the full source line with its
+        # line ending (none on a file's last line if the file doesn't end
+        # with one); any trailing whitespace on the blank line is kept.
         #
         def initialize( raw = '' )
           @raw = raw
         end
 
+        #
+        # The node's exact source text.
+        #
+        def text
+          return @raw
+        end
+
       end
     end
   end

data/lib/gloo/persist/source/comment_node.rb

@@ -14,13 +14,21 @@ module Gloo
         attr_reader :raw
 
         #
-        # Set up a comment node. raw is the full source line, minus
-        # its trailing newline.
+        # Set up a comment node. raw is the full source line, with
+        # its line ending (none on a file's last line if the file doesn't
+        # end with one).
         #
         def initialize( raw )
           @raw = raw
         end
 
+        #
+        # The node's exact source text.
+        #
+        def text
+          return @raw
+        end
+
       end
     end
   end

data/lib/gloo/persist/source/directive_node.rb

@@ -13,13 +13,21 @@ module Gloo
         attr_reader :raw
 
         #
-        # Set up a directive node. raw is the full source line, minus
-        # its trailing newline.
+        # Set up a directive node. raw is the full source line, with
+        # its line ending (none on a file's last line if the file doesn't
+        # end with one).
         #
         def initialize( raw )
           @raw = raw
         end
 
+        #
+        # The node's exact source text.
+        #
+        def text
+          return @raw
+        end
+
       end
     end
   end