gloo 6.1.0 → 6.2.1

data/lib/gloo/objs/basic/string_msgs.rb

@@ -21,8 +21,46 @@ module Gloo
           .map { |m| m.to_s.sub( /\Amsg_/, '' ) }
       end
 
+      #
+      # Documentation for each message this mixin implements, for use
+      # in String and Text's doc_data (see help_shell). Kept here as
+      # the single source, since String and Text share the exact
+      # same message set and would otherwise have to keep two
+      # hand-written copies of this list in sync.
+      #
+      def self.message_docs
+        return [
+          'up — Convert the string to uppercase. This message changes the value of the string.',
+          'down — Convert the string to lowercase. This message changes the value of the string.',
+          'size — Get the size of the string. It will have the string size.',
+          'count_chars — Count the number of characters in the string. It will have the character count.',
+          'count_words — Count the number of words in the string. It will have the word count.',
+          'count_lines — Count the number of lines in the string. It will have the line count.',
+          'starts_with? ({str}) — Check if the string starts with the given string. A parameter is required: the string to look for at the beginning of this string. It will have a boolean.',
+          'ends_with? ({str}) — Check if the string ends with the given string. A parameter is required: the string to look for at the end of this string. It will have a boolean.',
+          'substring? ({str}) — Check if the string includes the given sub-string. A parameter is required: the string to look for in this string. It will have a boolean.',
+          'format_for_html — Format this string for HTML output. Tabs, spaces and returns are converted to HTML elements. The value of the string is changed.',
+          'encode64 — Base64 encode the string. This message changes the value of the string. It will have the encoded string.',
+          'decode64 — Decode the string from Base64. This message changes the value of the string. It will have the decoded string.',
+          'escape — Escape the string to make it URL safe. This message changes the value of the string. It will have the escaped string.',
+          'unescape — Unescape the string (from URL safe format). This message changes the value of the string. It will have the unescaped string.',
+          'gen_uuid — Set the value of the string to a newly generated, random UUID. This message changes the value of the string.',
+          'gen_alphanumeric ({len}) — Set the value of the string to a newly generated, random alphanumeric string. The {len} parameter is optional; the length is 10 if not specified. This message changes the value of the string.',
+          'gen_hex ({len}) — Set the value of the string to a newly generated, random hex string. The {len} parameter is optional; the length is 10 if not specified. This message changes the value of the string.',
+          'gen_base64 ({len}) — Set the value of the string to a newly generated, random base64 string. The {len} parameter is optional; the length is 12 if not specified. This message changes the value of the string.',
+          'trim — Strip whitespace from the beginning and end of the string. This message changes the value of the string. It will have the trimmed string.',
+          'sub ({from} {to}) — Substitute the first occurrence of {from} with {to}. Both parameters are required. This message changes the value of the string. It will have the result.',
+          'gsub ({from} {to}) — Substitute all occurrences of {from} with {to}. Both parameters are required. This message changes the value of the string. It will have the result.',
+          'split ({from} {to}) — Get the substring from index {from} up to (not including) index {to}. Indexes are 0-based; out-of-range indexes are clamped to the start or end of the string. Both parameters are required. Does not change the value of the string. It will have the substring.',
+          'splitl ({index}) — Get the substring to the left of index {index} (same as split (0, {index})). A parameter is required. Does not change the value of the string. It will have the substring.',
+          'splitr ({index}) — Get the substring from index {index} to the end of the string (same as split ({index}, size)). A parameter is required. Does not change the value of the string. It will have the substring.',
+          'split_list ({delim} {dst.path}) — Split the string by {delim} and put the parts into children of the container at {dst.path} (or an alias that points to one), one part per child, in order. Existing children are matched by position and have their values set; extra parts get new (untyped) children, numbered from 1; extra existing children are left alone. Both parameters are required. Does not change the value of the string. It will have the number of parts.',
+          'page — Show the value in a pager (less), for viewing long content a screen at a time.'
+        ]
+      end
 
-      # 
+
+      #
       # Strip whitespace from the beginning and end of the string.
       #
       def msg_trim
@@ -120,7 +158,115 @@ module Gloo
         end
       end
 
-      # 
+      #
+      # Get the substring from index {from} up to (not including) index {to}.
+      # Indexes are 0-based. Out-of-range indexes are clamped to the
+      # beginning or end of the string. Does not change the string's value.
+      #
+      def msg_split
+        return '' unless value
+
+        if @params&.token_count&.positive?
+          expr = Gloo::Expr::Expression.new( @engine, [ @params.tokens.first ] )
+          from = expr.evaluate.to_i
+          expr = Gloo::Expr::Expression.new( @engine, [ @params.tokens.last ] )
+          to = expr.evaluate.to_i
+
+          result = clamped_substring( from, to )
+          @engine.heap.it.set_to result
+          return result
+        else
+          # Error
+          @engine.log.error MISSING_PARAM_MSG
+          @engine.heap.it.set_to false
+          return false
+        end
+      end
+
+      #
+      # Get the substring to the left of (not including) index {index}.
+      # Same as split( 0, index ). Does not change the string's value.
+      #
+      def msg_splitl
+        return '' unless value
+
+        if @params&.token_count&.positive?
+          expr = Gloo::Expr::Expression.new( @engine, @params.tokens )
+          index = expr.evaluate.to_i
+
+          result = clamped_substring( 0, index )
+          @engine.heap.it.set_to result
+          return result
+        else
+          # Error
+          @engine.log.error MISSING_PARAM_MSG
+          @engine.heap.it.set_to false
+          return false
+        end
+      end
+
+      #
+      # Get the substring from index {index} to the end of the string.
+      # Same as split( index, size ). Does not change the string's value.
+      #
+      def msg_splitr
+        return '' unless value
+
+        if @params&.token_count&.positive?
+          expr = Gloo::Expr::Expression.new( @engine, @params.tokens )
+          index = expr.evaluate.to_i
+
+          result = clamped_substring( index, value.length )
+          @engine.heap.it.set_to result
+          return result
+        else
+          # Error
+          @engine.log.error MISSING_PARAM_MSG
+          @engine.heap.it.set_to false
+          return false
+        end
+      end
+
+      #
+      # Split the string by the given delimiter and put the parts into
+      # children of the target container, one part per child, in order.
+      # The target is a path to a container, or to an alias that points
+      # to one. Existing children are matched by position (not name) and
+      # have their values set; if there are more parts than children,
+      # new (untyped) children are created for the extras, numbered
+      # from 1. Existing children beyond the part count are left alone.
+      # The string's own value is unchanged; the number of parts is put
+      # into 'it'.
+      #
+      def msg_split_list
+        return unless value
+
+        if @params&.token_count.to_i < 2
+          @engine.log.error MISSING_PARAM_MSG
+          @engine.heap.it.set_to false
+          return false
+        end
+
+        expr = Gloo::Expr::Expression.new( @engine, [ @params.tokens.first ] )
+        delim = expr.evaluate
+
+        target = split_list_target( @params.tokens.last )
+        return false unless target
+
+        parts = value.split( delim )
+        existing = target.children
+        parts.each_with_index do |part, index|
+          child = existing[ index ]
+          child ||= target.find_add_child( ( index + 1 ).to_s, 'untyped' )
+          child.set_value part
+        end
+
+        count = parts.count
+        @engine.heap.it.set_to count
+        return count
+      end
+
+      #
       # Does the string contain the given string?
       #
       # This was formerly an overload of obj.contains?
@@ -344,6 +490,50 @@ module Gloo
         @engine.platform.page( value )
       end
 
+      private
+
+      #
+      # Resolve the target container path for split_list. The path may
+      # point directly at a container, or at an alias that points to
+      # one. Returns nil (and logs an error, setting 'it' to false)
+      # if the path doesn't exist or doesn't resolve to a container.
+      #
+      def split_list_target( token )
+        pn = Gloo::Core::Pn.new( @engine, token )
+        unless pn&.exists?
+          @engine.log.error 'Target container path does not exist!'
+          @engine.heap.it.set_to false
+          return nil
+        end
+
+        target = pn.resolve
+        target = Gloo::Objs::Alias.resolve_alias( @engine, target )
+        unless target&.is_container?
+          @engine.log.error 'Target for split_list must be a container!'
+          @engine.heap.it.set_to false
+          return nil
+        end
+
+        return target
+      end
+
+      #
+      # Get the substring from index {from} up to (not including) index {to}.
+      # Out-of-range indexes are clamped to the string's own bounds (0 and
+      # its length), rather than raising an error. A degenerate range
+      # (from at or past to) returns an empty string.
+      #
+      def clamped_substring( from, to )
+        len = value.length
+        from = 0 if from.negative?
+        from = len if from > len
+        to = 0 if to.negative?
+        to = len if to > len
+        return '' if from >= to
+
+        return value[ from...to ]
+      end
+
     end
   end
 end

data/lib/gloo/objs/basic/text.rb

@@ -73,32 +73,11 @@ module Gloo
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
           :description => 'A longer, multi-line text string. Use BEGIN ' \
-            'and END to mark the text range.',
-          :messages => [
-            'Same messages as the string object type:',
-            'up — Convert the string to uppercase. This message changes the value of the string.',
-            'down — Convert the string to lowercase. This message changes the value of the string.',
-            'size — Get the size of the string. It will have the string size.',
-            'count_chars — Count the number of characters in the string. It will have the character count.',
-            'count_words — Count the number of words in the string. It will have the word count.',
-            'count_lines — Count the number of lines in the string. It will have the line count.',
-            'starts_with? ({str}) — Check if the string starts with the given string. A parameter is required: the string to look for at the beginning of this string. It will have a boolean.',
-            'ends_with? ({str}) — Check if the string ends with the given string. A parameter is required: the string to look for at the end of this string. It will have a boolean.',
-            'substring? ({str}) — Check if the string includes the given sub-string. A parameter is required: the string to look for in this string. It will have a boolean.',
-            'format_for_html — Format this string for HTML output. Tabs, spaces and returns are converted to HTML elements. The value of the string is changed.',
-            'encode64 — Base64 encode the string. This message changes the value of the string. It will have the encoded string.',
-            'decode64 — Decode the string from Base64. This message changes the value of the string. It will have the decoded string.',
-            'escape — Escape the string to make it URL safe. This message changes the value of the string. It will have the escaped string.',
-            'unescape — Unescape the string (from URL safe format). This message changes the value of the string. It will have the unescaped string.',
-            'gen_uuid — Set the value of the string to a newly generated, random UUID. This message changes the value of the string.',
-            'gen_alphanumeric ({len}) — Set the value of the string to a newly generated, random alphanumeric string. The {len} parameter is optional; the length is 10 if not specified. This message changes the value of the string.',
-            'gen_hex ({len}) — Set the value of the string to a newly generated, random hex string. The {len} parameter is optional; the length is 10 if not specified. This message changes the value of the string.',
-            'gen_base64 ({len}) — Set the value of the string to a newly generated, random base64 string. The {len} parameter is optional; the length is 12 if not specified. This message changes the value of the string.',
-            'trim — Strip whitespace from the beginning and end of the string. This message changes the value of the string. It will have the trimmed string.',
-            'sub ({from}, {to}) — Substitute the first occurrence of {from} with {to}. Both parameters are required. This message changes the value of the string. It will have the result.',
-            'gsub ({from}, {to}) — Substitute all occurrences of {from} with {to}. Both parameters are required. This message changes the value of the string. It will have the result.',
-            'page — Show the value in a pager (less), for viewing long content a screen at a time.'
-          ],
+            'and END to mark the text range. Shares the same messages ' \
+            'as the string object type; the two differ mainly by ' \
+            'convention — text for longer, multi-line blocks, string ' \
+            'for a single word or line.',
+          :messages => StringMsgs.message_docs,
           :examples => <<~EXAMPLES.strip
             t [container] :
               msg [txt] : BEGIN

data/lib/gloo/objs/ctrl/function.rb

@@ -161,23 +161,36 @@ module Gloo
       #    Messages
       # ---------------------------------------------------------------------
 
-      # 
+      #
       # Invoke the function, run the script and return the result.
-      # 
+      #
+      # If on_invoke itself hits an error, it is left alone rather
+      # than being clobbered with an unreliable result - callers can
+      # tell this happened because the engine is left in an error
+      # state (@engine.heap.error), same as any other failed verb.
+      #
       def invoke args
         @engine.log.debug "Invoking function: #{name}"
 
         set_params args if args
+
+        @engine.heap.error.start_tracking
         run_on_invoke
+        failed = @engine.heap.error.error_count.positive?
+
+        if failed
+          run_after_invoke
+          return nil
+        end
 
-        if @engine.running_app&.obj&.embedded_renderer 
+        if @engine.running_app&.obj&.embedded_renderer
           return_value = @engine.running_app.obj.embedded_renderer.render result, params_hash
         else
           return_value = result
         end
         @engine.heap.it.set_to return_value
         run_after_invoke
-        
+
         return return_value
       end
 

data/lib/gloo/verbs/help.rb

@@ -12,7 +12,7 @@ module Gloo
       KEYWORD_SHORT = '?'.freeze
 
       BANNER = "Entering the gloo help shell. Type 'quit' to exit.\n" \
-        "Try: verbs, objects, settings, extensions, libraries, docs, " \
+        "Try: verbs, objects, settings, theme, extensions, libraries, docs, " \
         "verb {name}, object {name}, doc {name}, library {name}, extension {name}\n".freeze
 
       #
@@ -50,12 +50,14 @@ module Gloo
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
           :description => 'Enter the interactive help shell. From there, ' \
-            'look up verbs, object types, settings, extensions, libraries, ' \
-            'and narrative doc pages, or get detailed help for a specific ' \
-            'verb, object, doc page, loaded library, or loaded extension.',
+            'look up verbs, object types, settings, the current color ' \
+            'theme, extensions, libraries, and narrative doc pages, or ' \
+            'get detailed help for a specific verb, object, doc page, ' \
+            'loaded library, or loaded extension.',
           :syntax => [ 'help' ],
           :result => "Enters the help shell, prompt \"help> \". Commands: " \
-            'verbs, objects, settings, extensions, libraries, docs (lists), ' \
+            'verbs, objects, settings, theme, extensions, libraries, docs ' \
+            '(lists — theme also shows a color preview of both palettes), ' \
             'verb {name}, object {name}, doc {name}, library {name}, ' \
             'extension {name} (detail for one, tab-completable — library ' \
             '{name} / extension {name} show the README for a loaded core ' \
@@ -65,6 +67,7 @@ module Gloo
             help> verbs
             help> verb put
             help> object container
+            help> theme
             help> docs
             help> doc getting_started
             help> library db

data/lib/gloo/verbs/invoke.rb

@@ -3,6 +3,10 @@
 #
 # Invoke a function from a script.
 #
+# Resolution, validation and the actual invoke are all handled by
+# Gloo::Core::Invoker, shared with inline calls inside expressions
+# (see Gloo::Expr::Call) so both go through the same error handling.
+#
 
 module Gloo
   module Verbs
@@ -15,24 +19,10 @@ module Gloo
       # Run the verb.
       #
       def run
-        if @tokens.token_count > 1
-          ob = @tokens.first
-
-          # Get the function object
-          pn = Gloo::Core::Pn.new( @engine, @tokens.second ) 
-          func = pn.resolve
-
-          # Is the object a function?
-          if func&.is_function?
-            params = get_params_arr
-          
-            @engine.log.debug "invoking function: #{func.pn}"
-            result = func.invoke( params ) 
-            @engine.log.debug "function returned: #{result}"
-            @engine.heap.it.set_to result
-            return result
-          end
-        end
+        target = @tokens.token_count > 1 ? @tokens.second : nil
+        arg_tokens = @tokens.token_count > 1 ? @tokens.params[ 1..-1 ] : []
+
+        return Gloo::Core::Invoker.invoke( @engine, target, arg_tokens )
       end
 
       #
@@ -49,32 +39,6 @@ module Gloo
         return KEYWORD_SHORT
       end
 
-      # ---------------------------------------------------------------------
-      #    Private functions
-      # ---------------------------------------------------------------------
-
-      private
-
-      #
-      # Get params array.
-      #
-      def get_params_arr
-        @engine.log.debug "token params: #{@tokens.params}"
-        params = @tokens.params[1..-1]
-
-        @engine.log.info "params: #{params}"
-        evaluated_params = []
-
-        params.each do |p|
-          expr = Gloo::Expr::Expression.new( @engine, [ p ] )
-          evaluated_params << expr.evaluate
-        end
-
-        @engine.log.debug "evaluated_params: #{evaluated_params}"
-
-        return evaluated_params
-      end
-
       # ---------------------------------------------------------------------
       #    Verb Documentation
       # ---------------------------------------------------------------------
@@ -87,12 +51,36 @@ module Gloo
           :name => KEYWORD,
           :shortcut => KEYWORD_SHORT,
           :description => 'Invoke a function. Set it to the result of the function.',
-          :syntax => [ 'invoke {path.to.function} {params}' ],
+          :syntax => [
+            'invoke {path.to.function} {params}',
+            'invoke( {path.to.function} {params} )  — inline, usable inside any expression',
+            '~>( {path.to.function} {params} )      — inline, shortcut spelling'
+          ],
           :parameters => [
             '{path.to.function} — The function we want to invoke.',
             '{params} — The list of parameters to the function.'
           ],
-          :result => 'The result of the function is put into it.',
+          :result => 'The result of the function is put into it. The ' \
+            'inline forms (invoke(...), ~>(...)) can be used anywhere ' \
+            'an expression is evaluated - show, put ... into, if, ' \
+            'unless, eval, and more - and evaluate to the result ' \
+            'directly rather than going through it.',
+          :errors => [
+            "#{Gloo::Core::Invoker::NO_TARGET_ERR} — No function reference was given.",
+            "#{Gloo::Core::Invoker::NOT_FOUND_ERR}{path.to.function} — The path doesn't resolve to any object.",
+            "#{Gloo::Core::Invoker::NOT_FUNCTION_ERR}{path.to.function} — The path resolves to an object that isn't a function.",
+            "#{Gloo::Core::Invoker::PARAM_COUNT_ERR}{path.to.function} (expected N, got N) — The number of params given doesn't match what the function declares."
+          ],
+          :notes => 'If the function itself fails during invocation ' \
+            '(its on_invoke script hits an error), it is left ' \
+            'unchanged rather than being set to an unreliable result. ' \
+            'The underlying error is whatever was reported by the ' \
+            'failure inside the function. ' \
+            'Inline call params are space-separated, same as the ' \
+            'standalone verb - each one is evaluated as a single ' \
+            'token (a literal or object reference), not a multi-token ' \
+            "sub-expression, so invoke( f 3+4 ) won't parse 3+4 as " \
+            'one arg.',
           :examples => <<~EXAMPLES.strip
             #
             # Function examples
@@ -111,6 +99,11 @@ module Gloo
                 invoke functions.add 3 4
                 show it
 
+                # Inline, anywhere an expression is evaluated:
+                show invoke( functions.add 3 4 )
+                put ~>( functions.add 3 4 ) into total
+                show "Total: " + invoke( functions.add 3 4 )
+
                 show 'done' (white)
 
               #

data/lib/gloo/verbs/list.rb

@@ -73,16 +73,17 @@ module Gloo
       # Show object in standard format.
       #
       def show_obj( obj, indent = '  ' )
+        theme = @engine.theme
         if obj.multiline_value? && obj.value_is_array?
-          str = "#{indent}#{obj.name}".white
-          str << " [#{obj.type_display}] : ".yellow
+          str = theme.emphasis( "#{indent}#{obj.name}" )
+          str << theme.accent( " [#{obj.type_display}] : " )
           @engine.log.show str
           obj.value.each do |line|
             @engine.log.show "#{indent}  #{line}"
           end
         else
-          str = "#{indent}#{obj.name}".white
-          str << " [#{obj.type_display}] : ".yellow
+          str = theme.emphasis( "#{indent}#{obj.name}" )
+          str << theme.accent( " [#{obj.type_display}] : " )
           str << "#{obj.value}"
           @engine.log.show str
         end

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

@@ -7,6 +7,7 @@ tests [can] :
     string [can] :
 
       s [string] :
+      dst [can] :
 
       up_down [test] :
         description [string] : Convert string case
@@ -42,3 +43,56 @@ tests [can] :
           tell ^^.s to count_chars
           eval it = 5
           assert "expected 5 characters"
+
+      split [test] :
+        description [string] : Get a substring between two indexes
+        on_test [script] :
+          put 'one two three' into ^^.s
+          tell ^^.s to split (4 7)
+          eval it = 'two'
+          assert "expected split (4 7) to equal 'two'"
+          eval ^^.s = 'one two three'
+          assert "expected split to leave the string unchanged"
+
+      splitl [test] :
+        description [string] : Get the substring to the left of an index
+        on_test [script] :
+          put 'one two three' into ^^.s
+          tell ^^.s to splitl (7)
+          eval it = 'one two'
+          assert "expected splitl (7) to equal 'one two'"
+
+      splitr [test] :
+        description [string] : Get the substring from an index to the end
+        on_test [script] :
+          put 'one two three' into ^^.s
+          tell ^^.s to splitr (4)
+          eval it = 'two three'
+          assert "expected splitr (4) to equal 'two three'"
+
+      split_out_of_range [test] :
+        description [string] : Out-of-range split indexes clamp to the string's bounds
+        on_test [script] :
+          put 'one two three' into ^^.s
+          tell ^^.s to split (-5 4)
+          eval it = 'one '
+          assert "expected split (-5 4) to clamp to 'one '"
+          tell ^^.s to split (8 100)
+          eval it = 'three'
+          assert "expected split (8 100) to clamp to 'three'"
+
+      split_list [test] :
+        description [string] : Split a string into children of a target container
+        on_test [script] :
+          put 'one,two,three' into ^^.s
+          tell ^^.s to split_list (',' ^^.dst)
+          eval it = 3
+          assert "expected split_list to put the part count into it"
+          eval ^^.dst.1 = 'one'
+          assert "expected dst.1 to equal 'one'"
+          eval ^^.dst.2 = 'two'
+          assert "expected dst.2 to equal 'two'"
+          eval ^^.dst.3 = 'three'
+          assert "expected dst.3 to equal 'three'"
+          eval ^^.s = 'one,two,three'
+          assert "expected split_list to leave the string unchanged"

data/test.gloo/verbs/invoke.test.gloo

@@ -18,3 +18,76 @@ tests [can] :
           invoke tests.verbs.invoke.f
           eval it = 42
           assert "expected it to be 42"
+
+      add [ƒ] :
+        on_invoke [script] :
+          put ^.params.x + ^.params.y into ^.result
+        params [can] :
+          x [int] :
+          y [int] :
+        result [int] :
+
+      total [int] :
+
+      inline_invoke_in_show_test [test] :
+        description [string] : Inline invoke( ... ) works inside show.
+        on_test [script] :
+          show invoke( tests.verbs.invoke.add 3 4 )
+          eval it = 7
+          assert "expected it to be 7"
+
+      inline_shortcut_in_show_test [test] :
+        description [string] : Inline ~>( ... ) works inside show, same as invoke( ... ).
+        on_test [script] :
+          show ~>( tests.verbs.invoke.add 3 4 )
+          eval it = 7
+          assert "expected it to be 7"
+
+      inline_invoke_with_operator_test [test] :
+        description [string] : Inline invoke( ... ) composes with an operator.
+        on_test [script] :
+          show "Total: " + invoke( tests.verbs.invoke.add 3 4 )
+          eval it = "Total: 7"
+          assert "expected it to be 'Total: 7'"
+
+      inline_invoke_in_put_test [test] :
+        description [string] : Inline invoke( ... ) works inside put ... into.
+        on_test [script] :
+          put 0 into ^^.total
+          put invoke( tests.verbs.invoke.add 3 4 ) into ^^.total
+          eval ^^.total = 7
+          assert "expected total to be 7"
+
+      inline_invoke_in_if_test [test] :
+        description [string] : Inline invoke( ... ) works inside if.
+        on_test [script] :
+          eval false
+          if invoke( tests.verbs.invoke.add 3 4 ) = 7 then eval true
+          assert "expected the if branch to have run"
+
+      err_fired [bool] : false
+
+      on_error [script] :
+        put true into ^.err_fired
+
+      inline_invoke_error_test [test] :
+        description [string] : Inline invoke( ... ) reports an error for an unresolved target, same as the standalone verb.
+        on_test [script] :
+          put false into ^^.err_fired
+          show invoke( tests.verbs.invoke.no_such_function )
+          eval ^^.err_fired = true
+          assert "expected on_error to have fired for an unresolved inline call target"
+
+      greet [ƒ] :
+        on_invoke [script] :
+          put 'Hi, ' + ^.params.name into ^.result
+        params [can] :
+          name [string] :
+        result [string] :
+
+      inline_invoke_with_quoted_arg_test [test] :
+        description [string] : A quoted string arg inside invoke( ... ) is passed through as one arg, not split on its internal space.
+        on_test [script] :
+          show invoke( tests.verbs.invoke.greet "Bob Smith" )
+          eval it = "Hi, Bob Smith"
+          assert "expected it to be 'Hi, Bob Smith'"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gloo
 version: !ruby/object:Gem::Version
-  version: 6.1.0
+  version: 6.2.1
 platform: ruby
 authors:
 - Eric Crane
@@ -250,12 +250,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
-- ".travis.yml"
 - CLAUDE.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -275,6 +273,7 @@ files:
 - docs/operators.md
 - docs/plugins.md
 - docs/verbs.md
+- docs/web_app.md
 - exe/gloo
 - exe/o
 - gloo.gemspec
@@ -293,6 +292,7 @@ files:
 - lib/gloo/app/running_app.rb
 - lib/gloo/app/settings.rb
 - lib/gloo/app/table.rb
+- lib/gloo/app/theme.rb
 - lib/gloo/convert/converter.rb
 - lib/gloo/convert/falseclass_to_integer.rb
 - lib/gloo/convert/nilclass_to_date.rb
@@ -314,6 +314,7 @@ files:
 - lib/gloo/core/gloo_system.rb
 - lib/gloo/core/heap.rb
 - lib/gloo/core/here.rb
+- lib/gloo/core/invoker.rb
 - lib/gloo/core/it.rb
 - lib/gloo/core/literal.rb
 - lib/gloo/core/obj.rb
@@ -332,6 +333,7 @@ files:
 - lib/gloo/exec/runner.rb
 - lib/gloo/exec/script.rb
 - lib/gloo/exec/stack.rb
+- lib/gloo/expr/call.rb
 - lib/gloo/expr/expression.rb
 - lib/gloo/expr/l_boolean.rb
 - lib/gloo/expr/l_decimal.rb