gloo 6.7.1 → 7.0

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/dictionary.rb

@@ -27,10 +27,14 @@ module Gloo
       #
       # Get the singleton Dictionary and Initialize
       # if this is the first time.
+      # The engine is optional -- verbs/objects self-register at class
+      # load time, before any engine (and its log) exists. When an
+      # engine is given, it's used to report a duplicate-registration
+      # error; without one, duplicates are just silently skipped.
       #
-      def self.get
+      def self.get( engine=nil )
         o = Gloo::Core::Dictionary.instance
-        o.init if o.verbs.count == 0
+        o.init( engine ) if o.verbs.count == 0
         return o
       end
 
@@ -51,9 +55,9 @@ module Gloo
       #
       # Initialize verbs and objects in the dictionary.
       #
-      def init
-        init_verbs
-        init_objs
+      def init( engine=nil )
+        init_verbs( engine )
+        init_objs( engine )
       end
 
       #
@@ -145,15 +149,15 @@ module Gloo
       #
       # Register a verb after start up.
       #
-      def register_verb_post_start( verb_class )
-        add_verb verb_class
+      def register_verb_post_start( verb_class, engine=nil )
+        add_verb verb_class, engine
       end
 
       #
       # Register an object type after start up.
       #
-      def register_obj_post_start( obj_class )
-        add_object obj_class
+      def register_obj_post_start( obj_class, engine=nil )
+        add_object obj_class, engine
       end
 
       #
@@ -200,28 +204,32 @@ module Gloo
       #
       # Init the list of objects.
       #
-      def init_objs
+      def init_objs( engine=nil )
         @obj_references.each do |o|
-          add_object o
+          add_object o, engine
         end
       end
 
       #
       # Init the list of verbs.
       #
-      def init_verbs
+      def init_verbs( engine=nil )
         @verb_references.each do |v|
-          add_verb v
+          add_verb v, engine
         end
       end
 
-      # 
-      # Add an object to the dictionary
-      # 
-      def add_object( obj )
+      #
+      # Add an object to the dictionary.
+      # The engine is optional and is only used to report a
+      # duplicate-registration error -- when it's not given (e.g.
+      # self-registration at class load time), duplicates are just
+      # silently skipped.
+      #
+      def add_object( obj, engine=nil )
         # Make sure it hasn't already been registered
         if ( @objs.key?(obj.typename) || @objs.key?(obj.short_typename) )
-          @engine.err "duplicate object type '#{obj.typename}' or '#{obj.short_typename}'"
+          engine&.err "duplicate object type '#{obj.typename}' or '#{obj.short_typename}'"
           return
         end
 
@@ -232,12 +240,13 @@ module Gloo
       end
 
       #
-      # Add a verb to the dictionary
+      # Add a verb to the dictionary.
+      # The engine is optional -- see add_object.
       #
-      def add_verb( verb )
+      def add_verb( verb, engine=nil )
         # Make sure it hasn't already been registered
         if ( verb?( verb.keyword ) || verb?( verb.keyword_shortcut ) )
-          @engine.err "duplicate verb keyword '#{verb.keyword}' or '#{verb.keyword_shortcut}'"
+          engine&.err "duplicate verb keyword '#{verb.keyword}' or '#{verb.keyword_shortcut}'"
           return
         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/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

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