gloo 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2040934825cd8c004b50e10414322e232c68d30299d7696bef2ae2f23cdb3e8
-  data.tar.gz: 70374a3c6d010fcc1d84d34ac1036c41d12d9699d8ce3629baf3a58683f0aac9
+  metadata.gz: f1dca7b53440a446850b2c3bd58b9a2b3c66ef73156bf7e8e90bfba9ddd71032
+  data.tar.gz: 012614b36386042458633b635a4f28c33fd9be21a50be7bcf37271d8c2aa8360
 SHA512:
-  metadata.gz: 55b6ece805e4705bcc909de79b80bad0a188d72ccf547f74f272d7f50d720d19e5c9412a99247378f9675f11f53b940ef6a83c05fc5dccf5b87b925742a140f6
-  data.tar.gz: b53f60308d786d1d4a90ac4e6e8aceb0527832f824b2110d72b767d55bf5f7ed3df467da22df8be0c7ea240462cee1cb21ce9a30c9859f469635133f3687f56c
+  metadata.gz: 0ae04823687860a34d4134bc9f3338a7d05dd68b6cd618d8ef8f1f51198bbcd2ea692f3737ab6e235f175ffa184114c6158071fc743ccc1073cba27d1d4efca0
+  data.tar.gz: 4a0c04fb3f64e2d7c045b72fd4a6f7c8b8d172b18b030de033d492803adf67eaf8c0f657e174b861d6de05172755f8bfb8273f3be42d53913c074923468371e7

data/lib/VERSION

@@ -1 +1 @@
-3.1.1
+3.2.0

data/lib/VERSION_NOTES

@@ -1,3 +1,9 @@
+3.2.0 - 2024.07.07
+ - Update with more web server functionality, http methods, resource routing
+ - Expands query with additional html table support
+ - Other web additions and expansion
+
+
 3.1.1 - 2024.04.26
  - Clean build
 

data/lib/gloo/app/log.rb

@@ -17,6 +17,8 @@ module Gloo
       ERROR = 'error'.freeze
       LEVELS = [ DEBUG, INFO, WARN, ERROR ].freeze
 
+      CLEARED = "\n\n --- Log files cleared. --- \n\n".freeze
+
       LOG_FILE = 'gloo.log'.freeze
       ERROR_FILE = 'error.log'.freeze
 
@@ -46,15 +48,32 @@ module Gloo
       # Create the default [file] logger.
       #
       def create_loggers
-        f = File.join( @engine.settings.log_path, LOG_FILE )
-        @logger = Logger.new( f )
+        @logger = Logger.new( log_file )
         @logger.level = Logger::DEBUG
 
-        err = File.join( @engine.settings.log_path, ERROR_FILE )
-        @error = Logger.new( err )
+        @error = Logger.new( err_file )
         @error.level = Logger::WARN
       end
 
+      # ---------------------------------------------------------------------
+      #    Files
+      # ---------------------------------------------------------------------
+
+      # 
+      # Get the log file.
+      # 
+      def log_file
+        return File.join( @engine.settings.log_path, LOG_FILE )
+      end
+
+      # 
+      # Get the error log file.
+      # 
+      def err_file
+        return File.join( @engine.settings.log_path, ERROR_FILE )
+      end
+
+
       # ---------------------------------------------------------------------
       #    Static Helpers
       # ---------------------------------------------------------------------
@@ -67,6 +86,21 @@ module Gloo
         return LEVELS.include? str.strip.downcase
       end
 
+      # ---------------------------------------------------------------------
+      #    Log file clearing
+      # ---------------------------------------------------------------------
+
+      # 
+      # Clear the log files.
+      # 
+      def clear
+        File.write( log_file, CLEARED )
+        File.write( err_file, CLEARED )
+
+        create_loggers
+      end
+
+
       # ---------------------------------------------------------------------
       #    Standard Output
       # ---------------------------------------------------------------------
@@ -74,8 +108,14 @@ module Gloo
       #
       # Show a message unless we're in quite mode.
       #
-      def show( msg )
-        puts msg unless @quiet
+      def show( msg, color=nil )
+        return if @quiet
+
+        if color
+          puts ColorizedString[ msg ].colorize( color.to_sym )
+        else
+          puts msg 
+        end
       end
 
       # ---------------------------------------------------------------------

data/lib/gloo/app/running_app.rb

@@ -10,7 +10,7 @@ module Gloo
   module App
     class RunningApp
 
-      attr_reader :obj
+      attr_reader :obj, :db_time
 
       #
       # Set up the running app for the given object.
@@ -19,6 +19,8 @@ module Gloo
         @engine = engine
         @log = @engine.log
         @obj = obj
+
+        @db_clients = {}
       end
 
       # 
@@ -36,6 +38,45 @@ module Gloo
         @log.debug "running app stopped for #{@obj.pn}"
       end
 
+
+      # ---------------------------------------------------------------------
+      #    DB function timer
+      # ---------------------------------------------------------------------
+
+      # 
+      # Add the given time to the db time.
+      #
+      def add_db_time time
+        @db_time = 0 unless @db_time
+        @db_time += time
+      end
+
+      # 
+      # Reset the db time to zero
+      # 
+      def reset_db_time
+        @db_time = 0
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Cached Database Connections
+      # ---------------------------------------------------------------------
+
+      # 
+      # Cache the given DB client for the given object.
+      # 
+      def cache_db_client( obj, client )
+        @db_clients[ obj.pn ] = client
+      end
+
+      # 
+      # Get the DB client for the given object.
+      # 
+      def db_client_for_obj( obj )
+        return @db_clients[ obj.pn ]
+      end
+
     end
   end
 end

data/lib/gloo/core/obj.rb

@@ -137,6 +137,14 @@ module Gloo
         return self.value.to_s.strip.empty?
       end
 
+      # 
+      # Is this an alias to another object?
+      # 
+      def is_alias?
+        return self.type_display == Gloo::Objs::Alias.typename
+      end
+
+
       # ---------------------------------------------------------------------
       #    Children
       # ---------------------------------------------------------------------
@@ -193,7 +201,7 @@ module Gloo
           return o if name.downcase == o.name.downcase
         end
 
-        if self.type_display == Gloo::Objs::Alias.typename
+        if is_alias?
           ln = Gloo::Core::Pn.new( @engine, self.value )
           redirect = ln.resolve
           return redirect.find_child( name )
@@ -201,6 +209,16 @@ module Gloo
         return nil
       end
 
+      #
+      # Get the index of the child with the given name.
+      # 
+      def child_index( name )
+        @children.each_with_index do |o, i|
+          return i if name.downcase == o.name.downcase
+        end
+        return nil
+      end
+
       #
       # Delete all children from the container.
       #
@@ -300,6 +318,21 @@ module Gloo
         @engine.persist_man.reload self
       end
 
+
+      # ---------------------------------------------------------------------
+      #    Render
+      # ---------------------------------------------------------------------
+
+      # 
+      # Render the object.
+      # By default this is just the object's value.
+      # The render_ƒ is 'render_html', 'render_text', 'render_json', etc.
+      # 
+      def render render_ƒ
+        return self.value.to_s
+      end
+
+
       # ---------------------------------------------------------------------
       #    Help
       # ---------------------------------------------------------------------

data/lib/gloo/exec/exec_env.rb

@@ -10,6 +10,7 @@ module Gloo
     class ExecEnv
 
       attr_accessor :verbs, :actions, :scripts, :here
+      attr_reader :running_script
 
       VERB_STACK = 'verbs'.freeze
       ACTION_STACK = 'actions'.freeze
@@ -22,6 +23,7 @@ module Gloo
       def initialize( engine )
         @engine = engine
         @engine.log.debug 'exec env intialized...'
+        @running_script = nil
 
         @verbs = Gloo::Exec::Stack.new( @engine, VERB_STACK )
         @actions = Gloo::Exec::Stack.new( @engine, ACTION_STACK )
@@ -43,6 +45,7 @@ module Gloo
       #
       def push_script( script )
         @scripts.push script
+        @running_script = script
         @here.push script.obj
       end
 
@@ -51,6 +54,7 @@ module Gloo
       #
       def pop_script
         @scripts.pop
+        @running_script = @scripts.stack.last
         @here.pop
       end
 

data/lib/gloo/exec/script.rb

@@ -9,13 +9,13 @@ module Gloo
     class Script
 
       attr_accessor :obj
-
       #
       # Set up the script.
       #
       def initialize( engine, obj )
         @engine = engine
         @obj = obj
+        @break_out = false
       end
 
       #
@@ -30,6 +30,7 @@ module Gloo
           @engine.parser.run @obj.value
         elsif @obj.value.is_a? Array
           @obj.value.each do |line|
+            break if @break_out
             @engine.parser.run line
           end
         end
@@ -45,6 +46,13 @@ module Gloo
         return @obj.pn
       end
 
+      # 
+      # Stop running this script.
+      # 
+      def break_out
+        @break_out = true
+      end
+
     end
   end
 end

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

@@ -33,7 +33,7 @@ module Gloo
       # Get a list of message names that this object receives.
       #
       def self.messages
-        return super + %w[count delete_children show_key_value_table]
+        return super + %w[count delete_children child_exists show_key_value_table]
       end
 
       #
@@ -57,9 +57,25 @@ module Gloo
       #
       def msg_show_key_value_table
         data = self.children.map { |o| [ o.name, o.value ] }
-        @engine.platform.show_table nil, data, title
+
+        # TODO: this doesn't work:
+        # @engine.platform.show_table nil, data, title
       end
 
+      # 
+      # Check to see if there is a child with the given name.
+      # 
+      def msg_child_exists
+        if @params&.token_count&.positive?
+          expr = Gloo::Expr::Expression.new( @engine, @params.tokens )
+          data = expr.evaluate
+        end
+        return unless data
+
+        val = self.contains_child?( data )
+        @engine.heap.it.set_to val
+        return val
+      end
     end
   end
 end

data/lib/gloo/objs/cli/menu.rb

@@ -68,7 +68,10 @@ module Gloo
       # 
       def add_loop_child
         o = find_child LOOP
-        return if o
+        if o
+          o.set_value true
+          return 
+        end
 
         fac = @engine.factory
         fac.create_bool LOOP, true, self
@@ -324,7 +327,7 @@ module Gloo
       # Run the selected command.
       #
       def run_command( cmd )
-        @engine.log.debug "Menu Command: #{cmd}"
+        @engine.log.info "Menu Command: #{cmd}"
         obj = find_cmd cmd
 
         if obj
@@ -335,15 +338,18 @@ module Gloo
           s.run
         else
           if cmd == '?'
+            @engine.log.debug 'Showing options'
             show_options
           elsif cmd == 'q!'
-            @engine.log.info 'Quitting Gloo'
+            @engine.log.debug 'Quitting Gloo'
             @engine.stop_running
           elsif cmd == 'qq'
+            @engine.log.debug 'Quitting to top level menu'
             pop_to_top_level_menu
           elsif cmd.starts_with? ':'
             gloo_cmd = cmd[1..-1].strip
             if gloo_cmd.blank?
+              @engine.log.debug 'Quitting all menus and dropping into Gloo'
               quit_all_menus
             else
               @engine.log.debug "Running Gloo command: #{gloo_cmd}"

data/lib/gloo/objs/data/mysql.rb

@@ -90,22 +90,42 @@ module Gloo
         @engine.heap.it.set_to true
       end
 
+
       # ---------------------------------------------------------------------
       #    DB functions (all database connections)
       # ---------------------------------------------------------------------
 
+      #
+      # Get the client object.
+      # It might be cached, so check first.
+      # If it is not cached, create a new one.
+      #
+      def get_client
+        app = @engine.running_app
+
+        client = app.db_client_for_obj( self ) if app 
+
+        unless client
+          h = {
+            host: host_value,
+            database: db_value,
+            username: user_value,
+            password: passwd_value
+          }
+          client = Mysql2::Client.new( h )
+
+          app.cache_db_client( self, client ) if app
+        end
+        
+        return client
+      end
+
       #
       # Open a connection and execute the SQL statement.
       # Return the resulting data.
       #
       def query( sql, params = nil )
-        h = {
-          host: host_value,
-          database: db_value,
-          username: user_value,
-          password: passwd_value
-        }
-        client = Mysql2::Client.new( h )
+        client = get_client
 
         heads = []
         data = []
@@ -134,6 +154,14 @@ module Gloo
         return [ heads, data ]
       end
 
+      # 
+      # Based on the result set, build a QueryResult object.
+      # 
+      def get_query_result( result )
+        return QueryResult.new result[0], result[1]
+      end
+
+
       # ---------------------------------------------------------------------
       #    Private functions
       # ---------------------------------------------------------------------

data/lib/gloo/objs/data/pg.rb

@@ -119,6 +119,14 @@ module Gloo
         return [ heads, data ]
       end
 
+      # 
+      # Based on the result set, build a QueryResult object.
+      # 
+      def get_query_result( result )
+        return QueryResult.new result[0], result[1]
+      end
+
+
       # ---------------------------------------------------------------------
       #    Private functions
       # ---------------------------------------------------------------------

data/lib/gloo/objs/data/query.rb

@@ -16,6 +16,7 @@ module Gloo
       SQL = 'sql'.freeze
       RESULT = 'result'.freeze
       PARAMS = 'params'.freeze
+      SIMPLE_LIST = 'simple_list'.freeze
 
       DB_MISSING_ERR = 'The database connection is missing!'.freeze
 
@@ -70,24 +71,69 @@ module Gloo
       end
 
       #
-      # SSH to the host and execute the command, then update result.
+      # Run the query and process the results.
       #
       def msg_run
         db = db_obj
-        unless db
-          @engine.err DB_MISSING_ERR
+        return unless db
+
+        begin
+          result = db.query( sql_value, param_array )
+          process_result( result, db )
+        rescue => e
+          @engine.err e.message
           return
         end
+      end
+
+      #
+      # Run the query and return the results.
+      #
+      def run_query
+        db = db_obj
+        return unless db
 
         begin
+          log_query sql_value, param_array
+
+          db_start = ::Time.now
           result = db.query( sql_value, param_array )
-          process_result result
+          db_done = ::Time.now
+          elapsed = ( ( db_done - db_start ) * 1000.0 ).round(2)
+  
+          app = @engine.running_app
+          app.add_db_time elapsed if app
+          return result
         rescue => e
           @engine.err e.message
           return
         end
       end
 
+      # 
+      # Write the query to the log.
+      # 
+      def log_query sql, params
+        @engine.log.info "QUERY PARAMS: #{params}" if params
+        @engine.log.info "QUERY: #{sql}"
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Output as simple list
+      # ---------------------------------------------------------------------
+
+      # 
+      # Should the output be put in a simple list?
+      # 
+      def simple_list?
+        o = find_child SIMPLE_LIST
+        return false unless o
+
+        return o.value
+      end
+
+
       # ---------------------------------------------------------------------
       #    Private functions
       # ---------------------------------------------------------------------
@@ -99,6 +145,12 @@ module Gloo
       #
       def db_obj
         o = find_child DB
+
+        unless o
+          @engine.err DB_MISSING_ERR
+          return nil
+        end
+
         return Gloo::Objs::Alias.resolve_alias( @engine, o )
       end
 
@@ -118,21 +170,24 @@ module Gloo
       # If there's a result container, we'll create objects in it.
       # If not, we'll just show the output in the console.
       #
-      def process_result( result )
+      def process_result( result, db )
         return if result.nil?
 
-        heads = result[0]
-        data = result[1]
-        qr = QueryResult.new heads, data
-        return unless qr.has_data_to_show?
+        query_result = db.get_query_result( result )
+        return unless query_result
+        return unless query_result.has_data_to_show?
 
         result_can = find_child RESULT
         result_can = Gloo::Objs::Alias.resolve_alias( @engine, result_can )
 
         if result_can
-          qr.update_result_container result_can
+          if simple_list?
+            query_result.update_result_container_simple result_can
+          else
+            query_result.update_result_container result_can
+          end
         else
-          qr.show
+          query_result.show
         end
       end
 

data/lib/gloo/objs/data/query_result.rb

@@ -98,6 +98,14 @@ module Gloo
         single_row_result? ? update_single_row : update_rows
       end
 
+      #
+      # Update the result container with the data from the query.
+      #
+      def update_result_container_simple( in_can )
+        @result_can = in_can
+        single_row_result? ? update_single_row : update_rows_simple
+      end
+
       # 
       # The result has a single row.
       # Map values from the result set to objects that are present.
@@ -122,7 +130,20 @@ module Gloo
           end
         end
       end
-      
+
+      # 
+      # Put all rows in the result object.
+      # 
+      def update_rows_simple
+        @data.each do |row|
+          row.each do |val|
+            o = @result_can.find_add_child( val, 'untyped' )
+            o.set_value val
+          end
+        end
+      end
+
+
       # ---------------------------------------------------------------------
       #    Private functions
       # ---------------------------------------------------------------------

data/lib/gloo/objs/data/sqlite.rb

@@ -116,10 +116,25 @@ module Gloo
         end
 
         db = SQLite3::Database.open name
-        db.results_as_hash = true
-        return db.query( sql, params )
+        # db.results_as_hash = true
+        results = db.query( sql, params )
+
+        return results
+      end
+
+      # 
+      # Based on the result set, build a QueryResult object.
+      # 
+      def get_query_result( result )
+        rows = []        
+        while ( row = result.next ) do
+          rows << row
+        end
+
+        return QueryResult.new( result.columns, rows )
       end
 
+
       # ---------------------------------------------------------------------
       #    Private functions
       # ---------------------------------------------------------------------