gloo 6.7.2 → 7.0.1

data/lib/gloo/convert/converter.rb

@@ -8,6 +8,16 @@ module Gloo
   module Convert
     class Converter
 
+      # How each type reads in a warning: "'x' is not an integer".
+      TYPE_NAMES = {
+        'Integer' => 'an integer',
+        'Decimal' => 'a decimal number',
+        'Date' => 'a date',
+        'Time' => 'a time',
+        'DateTime' => 'a date and time'
+      }.freeze
+      NO_CONVERSION_ERR = 'There is no conversion to '.freeze
+
       #
       # Initializer.
       #
@@ -23,12 +33,30 @@ module Gloo
       # Convert the given value to the specified type,
       # or if no conversion is available, revert to default.
       #
+      # If the value isn't really of that type (eg. 'x' for an
+      # integer), the conversion is still the best guess, and a warning
+      # says what was guessed. A kind of value there's no converter for
+      # is also warned about, using the default. Converting to a type
+      # that isn't known is an error.
+      #
       def convert( value, to_type, default = nil )
         begin
           name = "Gloo::Convert::#{value.class}To#{to_type}"
-          clazz = name.split( '::' ).inject( Object ) { |o, c| o.const_get c }
+          clazz = find_converter( name )
+          unless TYPE_NAMES.key?( to_type )
+            @engine.err "#{NO_CONVERSION_ERR}'#{to_type}'."
+            return default
+          end
+          unless clazz
+            @engine.warn "'#{value}' is not #{TYPE_NAMES[ to_type ]}; " \
+              "using #{default.nil? ? 'no value' : default}."
+            return default
+          end
+
           o = clazz.new
-          return o.convert( value )
+          result = o.convert( value )
+          warn_bad_value( o, value, result, to_type )
+          return result
         rescue => e
           @engine.log_exception e
         end
@@ -36,6 +64,39 @@ module Gloo
         return default
       end
 
+      private
+
+      #
+      # Find the converter class by name, or nil if there isn't one for
+      # that kind of value.
+      #
+      def find_converter( name )
+        return name.split( '::' ).inject( Object ) { |o, c| o.const_get( c, false ) }
+      rescue NameError
+        return nil
+      end
+
+      #
+      # Warn if the converter says the value isn't valid for its type.
+      #
+      def warn_bad_value( converter, value, result, to_type )
+        return unless converter.respond_to?( :valid? )
+        return if converter.valid?( value, result )
+
+        @engine.warn "'#{value}' is not #{TYPE_NAMES[ to_type ]}; " \
+          "using #{describe( converter, result )}."
+      end
+
+      #
+      # Describe the guess for a warning.
+      #
+      def describe( converter, result )
+        return 'no value' if result.nil?
+        return converter.describe( result ) if converter.respond_to?( :describe )
+
+        return result.to_s
+      end
+
     end
   end
 end

data/lib/gloo/convert/string_to_date.rb

@@ -21,6 +21,20 @@ module Gloo
         return Chronic.parse( value )
       end
 
+      #
+      # Is the value really a date? A blank value is no value.
+      #
+      def valid?( value, result )
+        return value.blank? || !result.nil?
+      end
+
+      #
+      # Describe the guess for a warning.
+      #
+      def describe( result )
+        return result.strftime( Gloo::Objs::Date::DEFAULT_FORMAT )
+      end
+
     end
   end
 end

data/lib/gloo/convert/string_to_datetime.rb

@@ -16,6 +16,22 @@ module Gloo
         return Chronic.parse( value )
       end
 
+      #
+      # Is the value really a date and time? A blank value is no value.
+      #
+      def valid?( value, result )
+        return true if value.blank?
+
+        return !result.nil? && !StringToTime.clock_out_of_range?( value )
+      end
+
+      #
+      # Describe the guess for a warning.
+      #
+      def describe( result )
+        return result.strftime( Gloo::Objs::DateTime::DEFAULT_FORMAT )
+      end
+
     end
   end
 end

data/lib/gloo/convert/string_to_decimal.rb

@@ -15,6 +15,19 @@ module Gloo
         return value.to_f
       end
 
+      #
+      # Is the value really a decimal number? A blank value is no
+      # value (0.0).
+      #
+      def valid?( value, _result )
+        return true if value.blank?
+
+        Float( value.strip )
+        return true
+      rescue ArgumentError
+        return false
+      end
+
     end
   end
 end

data/lib/gloo/convert/string_to_integer.rb

@@ -12,11 +12,18 @@ module Gloo
       # Convert the given string value to an integer.
       #
       def convert( value )
-        return nil if value.blank?
-        
+        return 0 if value.blank?
+
         return value.to_i
       end
 
+      #
+      # Is the value really an integer? A blank value is no value (0).
+      #
+      def valid?( value, _result )
+        return value.blank? || value.match?( /\A\s*[-+]?\d+\s*\z/ )
+      end
+
     end
   end
 end

data/lib/gloo/convert/string_to_time.rb

@@ -16,6 +16,34 @@ module Gloo
         return Chronic.parse( value )
       end
 
+      #
+      # Is the value really a time? A blank value is no value. A clock
+      # time out of range (eg. 25:99) is parsed, but rolls over.
+      #
+      def valid?( value, result )
+        return true if value.blank?
+
+        return !result.nil? && !StringToTime.clock_out_of_range?( value )
+      end
+
+      #
+      # Describe the guess for a warning.
+      #
+      def describe( result )
+        return result.strftime( Gloo::Objs::Time::DEFAULT_FORMAT )
+      end
+
+      #
+      # Does the value have a clock time (h:mm or h:mm:ss) with an hour,
+      # minute or second out of range?
+      #
+      def self.clock_out_of_range?( value )
+        m = value.match( /(\d{1,2}):(\d{2})(?::(\d{2}))?/ )
+        return false unless m
+
+        return m[ 1 ].to_i > 24 || m[ 2 ].to_i > 59 || m[ 3 ].to_i > 59
+      end
+
     end
   end
 end

data/lib/gloo/core/error.rb

@@ -8,7 +8,12 @@ module Gloo
   module Core
     class Error
 
-      attr_accessor :value, :error_count
+      # The kind of error: the command couldn't be understood (syntax),
+      # or it was understood but couldn't be done (runtime).
+      SYNTAX = 'syntax'.freeze
+      RUNTIME = 'runtime'.freeze
+
+      attr_accessor :value, :error_count, :kind, :location
 
       #
       # Set up the error object.
@@ -23,14 +28,18 @@ module Gloo
       def clear
         @error_count = 0
         @value = nil
+        @kind = nil
+        @location = nil
       end
 
       #
       # Set the value of error.
       #
-      def set_to( new_value )
+      def set_to( new_value, kind = RUNTIME, location = nil )
         @error_count += 1
         @value = new_value
+        @kind = kind
+        @location = location
       end
 
       #

data/lib/gloo/core/event_manager.rb

@@ -75,16 +75,19 @@ module Gloo
       # 
       # Run the on_error scripts in any open objects.
       # For each on_error script found, look for the error_data container
-      # and set the error message and backtrace.
+      # and set the error message, backtrace, kind (syntax or runtime)
+      # and location -- each only if error_data has that child.
       # 
-      def on_error msg, backtrace
+      def on_error msg, backtrace, kind = Gloo::Core::Error::RUNTIME, location = nil
         @engine.log.debug 'on_error event'
         arr = Gloo::Core::ObjFinder.by_name( @engine, 'on_error' )
         arr.each do |o|
           data = o.parent.find_child 'error_data'
           if data
-            data.find_child( 'message' ).set_value msg
-            data.find_child( 'backtrace' ).set_value backtrace
+            data.find_child( 'message' )&.set_value msg
+            data.find_child( 'backtrace' )&.set_value backtrace
+            data.find_child( 'kind' )&.set_value kind
+            data.find_child( 'location' )&.set_value location
           end
 
           Gloo::Exec::Dispatch.message( @engine, 'run', o )

data/lib/gloo/core/factory.rb

@@ -8,6 +8,9 @@ module Gloo
   module Core
     class Factory < Baseo
 
+      UNTYPED = 'untyped'.freeze
+      UNKNOWN_TYPE_ERR = 'Unknown type '.freeze
+
       # ---------------------------------------------------------------------
       #    Initializer
       # ---------------------------------------------------------------------
@@ -155,6 +158,12 @@ module Gloo
           return self.update_existing pn, params[ :value ]
         end
 
+        unless parent
+          missing = pn.elements[ 0..-2 ].join( '.' )
+          @engine.err "Could not create '#{params[ :name ]}': #{Gloo::Core::NotFound.object( missing )}"
+          return nil
+        end
+
         @engine.log.debug "Creating new object: #{obj_name}"
         return create_new obj_name, params[ :value ], objtype, parent
       end
@@ -163,11 +172,6 @@ module Gloo
       # Create a new object.
       #
       def create_new( name, value, type, parent )
-        unless parent
-          @engine.err "Could not create object.  Bad path: #{name}"
-          return nil
-        end
-
         # Check to see if the object exists already
         return parent.find_child( name ) if parent.contains_child?( name )
 
@@ -189,20 +193,21 @@ module Gloo
 
       #
       # Find the object type by name.
-      # Return nil if the object type cannot be found or
-      # cannot be created.
+      # An unknown type is a syntax error; the best guess is untyped,
+      # so the object (and anything nested under it) is still created.
+      # Return nil if the object type cannot be created.
       #
       def find_type( type_name )
-        type_name = 'untyped' if type_name.nil? || type_name.strip.empty?
+        type_name = UNTYPED if type_name.nil? || type_name.strip.empty?
         t = @engine.dictionary.find_obj( type_name )
 
         if t.nil?
-          @engine.log.warn "Could not find type, '#{type_name}'"
-          return nil
+          @engine.syntax_err "#{UNKNOWN_TYPE_ERR}'#{type_name}'; using untyped."
+          t = @engine.dictionary.find_obj( UNTYPED )
         end
 
         unless t.can_create?
-          @engine.err "'#{type_name}' cannot be created."
+          @engine.syntax_err "'#{type_name}' cannot be created."
           return nil
         end
 

data/lib/gloo/core/gloo_system.rb

@@ -246,7 +246,7 @@ module Gloo
 
       # Is the platform Linux?
       def msg_platform_linux?
-        return OS.posix?
+        return OS.linux?
       end
 
       # Is the platform Mac?
@@ -322,7 +322,8 @@ module Gloo
             'platform_windows? — Is the platform Windows?',
             'platform_unix? — Is the platform Unix?',
             'platform_linux? — Is the platform Linux?',
-            'platform_mac? — Is the platform Mac?'
+            'platform_mac? — Is the platform Mac?',
+            'platform_wsl? — Is the platform WSL (Linux on Windows)?'
           ],
           :examples => <<~EXAMPLES.strip
             > show gloo.user

data/lib/gloo/core/here.rb

@@ -23,11 +23,16 @@ module Gloo
       #
       def self.expand_here( engine, pn )
         target = engine.exec_env.here_obj
+        # Outside a running script there's nothing for ^ to be
+        # relative to; leave the path as is, so the lookup finds nothing.
+        return unless target
 
         here = pn.elements.first
         remainder = pn.elements[ 1..-1 ].join( '.' )
 
-        here.length.times { target = target.parent }
+        here.length.times { target = target&.parent }
+        return unless target
+
         full_path = target.pn.empty? ? remainder : "#{target.pn}.#{remainder}"
         pn.set_to full_path
       end

data/lib/gloo/core/invoker.rb

@@ -12,7 +12,6 @@ module Gloo
     class Invoker
 
       NO_TARGET_ERR = 'Missing function reference!'.freeze
-      NOT_FOUND_ERR = 'Object was not found: '.freeze
       NOT_FUNCTION_ERR = 'Not a function: '.freeze
       PARAM_COUNT_ERR = 'Wrong number of parameters for function: '.freeze
 
@@ -26,7 +25,7 @@ module Gloo
       #
       def self.invoke( engine, target, arg_tokens )
         if target.nil? || target.to_s.strip.empty?
-          engine.err NO_TARGET_ERR
+          engine.syntax_err NO_TARGET_ERR
           return nil
         end
 
@@ -49,7 +48,7 @@ module Gloo
         func = pn.resolve
 
         unless func
-          engine.err "#{NOT_FOUND_ERR}#{target}"
+          engine.err Gloo::Core::NotFound.object( target )
           return nil
         end
 

data/lib/gloo/core/not_found.rb

@@ -0,0 +1,42 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2026 Eric Crane.  All rights reserved.
+#
+# The one wording for "not found" errors, so every command reports
+# a missing object, file, folder or verb the same way.
+#
+
+module Gloo
+  module Core
+    module NotFound
+
+      #
+      # An object path that doesn't resolve, shown as written.
+      #
+      def self.object( path )
+        return "Object '#{path}' was not found."
+      end
+
+      #
+      # A file that doesn't exist.
+      #
+      def self.file( name )
+        return "File '#{name}' was not found."
+      end
+
+      #
+      # A folder that doesn't exist.
+      #
+      def self.folder( name )
+        return "Folder '#{name}' was not found."
+      end
+
+      #
+      # A verb that isn't in the dictionary.
+      #
+      def self.verb( name )
+        return "Verb '#{name}' was not found."
+      end
+
+    end
+  end
+end

data/lib/gloo/core/obj.rb

@@ -241,7 +241,7 @@ module Gloo
       #
       def contains_child?( name )
         @children.each do |o|
-          return true if name.downcase == o.name.downcase
+          return true if name.to_s.downcase == o.name.downcase
         end
         return false
       end
@@ -261,7 +261,7 @@ module Gloo
         if is_alias?
           ln = Gloo::Core::Pn.new( @engine, self.value )
           redirect = ln.resolve
-          return redirect.find_child( name )
+          return redirect&.find_child( name )
         end
         return nil
       end
@@ -349,6 +349,29 @@ module Gloo
         return msgs.include?( msg.strip.downcase )
       end
 
+      #
+      # Run a step of a message that can fail on ordinary bad input or
+      # the outside world (invalid JSON, an unknown host, a wrong key).
+      # Returns true if the block ran. If it raises one of the given
+      # exception classes, report it as a gloo error ("Could not
+      # {action}: {reason}"), put false into it (unless set_it is
+      # false, for an action that doesn't set it), and return false.
+      # Any other exception is left alone, so a real bug still shows
+      # up as one.
+      #
+      #   return false unless attempt( 'parse the JSON', JSON::ParserError ) do
+      #     json = JSON.parse( value )
+      #   end
+      #
+      def attempt( action, *errors, set_it: true )
+        yield
+        return true
+      rescue *errors => e
+        @engine.err "Could not #{action}: #{e.message}"
+        @engine.heap.it.set_to false if set_it
+        return false
+      end
+
       #
       # Sent this object the given message.
       #
@@ -356,7 +379,9 @@ module Gloo
         @params = params
         return self.dispatch msg if self.can_receive_message? msg
 
+        # The message never ran, so there is no result.
         @engine.err "Object #{self.name} cannot receive message #{msg}"
+        @engine.heap.it.set_to false
         return false
       end
 
@@ -370,6 +395,7 @@ module Gloo
           return true
         else
           @engine.err "Message #{msg} not implemented"
+          @engine.heap.it.set_to false
           return false
         end
       end
@@ -420,7 +446,8 @@ module Gloo
       end
 
       # 
-      # Check to see if the value is blank.
+      # Check to see if the simple value is blank.
+      # Children aren't considered; use contains? for those.
       # 
       def msg_blank?
         val_blank = value.blank?

data/lib/gloo/core/op.rb

@@ -15,6 +15,7 @@ module Gloo
       def self.op?( token )
         return [ 
           Gloo::Expr::OpPlus::SYMBOL,
+          Gloo::Expr::OpPlus::ALT_SYMBOL,
           Gloo::Expr::OpMinus::SYMBOL,
           Gloo::Expr::OpMult::SYMBOL,
           Gloo::Expr::OpDiv::SYMBOL,
@@ -34,6 +35,7 @@ module Gloo
       def self.create_op( token )
         case token
           when Gloo::Expr::OpPlus::SYMBOL then Gloo::Expr::OpPlus.new
+          when Gloo::Expr::OpPlus::ALT_SYMBOL then Gloo::Expr::OpPlus.new
           when Gloo::Expr::OpMinus::SYMBOL then Gloo::Expr::OpMinus.new
           when Gloo::Expr::OpMult::SYMBOL then Gloo::Expr::OpMult.new
           when Gloo::Expr::OpDiv::SYMBOL then Gloo::Expr::OpDiv.new

data/lib/gloo/core/parser.rb

@@ -35,7 +35,7 @@ module Gloo
         verb = dic.find_verb( tokens.verb )
         return verb.new( @engine, tokens, params ) if verb
 
-        @engine.err "Verb '#{tokens.verb}' was not found."
+        @engine.syntax_err Gloo::Core::NotFound.verb( tokens.verb )
         return nil
       end
 

data/lib/gloo/core/pn.rb

@@ -14,6 +14,8 @@ module Gloo
       ERROR = 'error'.freeze
       CONTEXT = '@'.freeze
       NAMED_COLORS = %w[red blue green white black yellow].freeze
+      IT_NOT_AN_OBJECT = "it isn't an object and can't be %s; %s.".freeze
+      IT_HINT = 'put it into an object first (put it into x)'.freeze
 
       attr_reader :src, :elements
 
@@ -61,6 +63,19 @@ module Gloo
         return @src.downcase == IT
       end
 
+      #
+      # it is a read-only result value, not an object, so it can't
+      # be the target of a verb or message. If the path refers to it,
+      # report that (what it can't be: 'sent messages', 'run', ...,
+      # and what to do instead) and return true.
+      #
+      def it_target_err?( what, hint = IT_HINT )
+        return false unless self.it?
+
+        @engine.err format( IT_NOT_AN_OBJECT, what, hint )
+        return true
+      end
+
       #
       # Does the pathname reference refer to error?
       #
@@ -141,19 +156,29 @@ module Gloo
         self.set_to( "#{@engine.heap.context}#{@src[1..-1]}" )
       end
 
+      #
+      # Expand any here (^) or context (@) reference into the
+      # full path, so the lookup below starts from the heap root.
+      #
+      def expand_refs
+        Here.expand_here( @engine, self ) if Here.includes_here_ref?( @elements )
+        expand_context if self.includes_context?
+      end
+
       #
       # Get the parent that contains the object referenced.
       #
+      # This is a lookup, not a use of the object: a missing element
+      # returns nil without reporting an error. A caller that needs the
+      # object reports its own error.
+      #
       def get_parent
         o = @engine.heap.root
 
         if self.includes_path?
           @elements[ 0..-2 ].each do |e|
             o = o.find_child( e )
-            if o.nil?
-              @engine.err "Object '#{e}' was not found."
-              return nil
-            end
+            return nil if o.nil?
           end
         end
 
@@ -162,12 +187,14 @@ module Gloo
 
       #
       # Does the object at the path exist?
+      # A question, so a missing object is an answer, not an error.
       #
       def exists?
         return true if self.root?
         return true if self.it?
         return true if self.error?
 
+        expand_refs
         parent = self.get_parent
         return false unless parent
 
@@ -186,6 +213,7 @@ module Gloo
       #
       # Resolve the pathname reference.
       # Find the object referenced or return nil if it is not found.
+      # Like get_parent, a missing object is not reported here.
       #
       def resolve
         return @engine.heap.root if self.root?
@@ -194,14 +222,7 @@ module Gloo
         return Gloo::Core::GlooSystem.new(
           @engine, self ) if self.gloo_sys?
 
-        if Here.includes_here_ref?( @elements )
-          Here.expand_here( @engine, self )
-        end
-
-        if self.includes_context?
-          expand_context
-        end
-
+        expand_refs
         parent = self.get_parent
         return nil unless parent