gloo 3.1.1 → 3.3.0

data/lib/gloo/objs/data/markdown.rb

@@ -3,6 +3,7 @@
 #
 # Markdown data.
 #
+require 'redcarpet'
 
 module Gloo
   module Objs
@@ -55,7 +56,7 @@ module Gloo
       # Get a list of message names that this object receives.
       #
       def self.messages
-        return super + %w[show page]
+        return super + %w[show page render]
       end
 
       #
@@ -71,9 +72,66 @@ module Gloo
       def msg_page
         return unless self.value
 
-        @engine.platform.show( md, true, true )
+        @engine.platform.show( self.value, true, true )
       end
 
+      #
+      # Render the markdown as HTML.
+      # Needs an optional parameter of where to put the rendered html.
+      # The html will be in 'it' as well.
+      #
+      def msg_render
+        html = Gloo::Objs::Markdown.md_2_html( value )
+
+        # Put the HTML in the optional parameter if one is given.
+        if @params&.token_count&.positive?
+          pn = Gloo::Core::Pn.new( @engine, @params.first )
+          o = pn.resolve
+          o.set_value html
+        end
+
+        # Put the HTML in it, in any case.
+        @engine.heap.it.set_to html
+      end
+
+      # ---------------------------------------------------------------------
+      #    Static Helpers
+      # ---------------------------------------------------------------------
+
+      # 
+      # Convert markdown to HTML using the
+      # Redcarpet markdown processor.
+      # 
+      def self.md_2_html( md )
+        markdown = Redcarpet::Markdown.new( 
+          Redcarpet::Render::HTML, 
+          autolink: true, 
+          fenced_code_blocks: true,
+          tables: true, 
+          strikethrough: true )
+          
+        return markdown.render( md )
+      end
+
+      # 
+      # Does not work.
+      # See note in the platform.rb file.
+      # 
+      # # 
+      # # Convert markdown to manpage using the
+      # # Redcarpet markdown processor.
+      # # 
+      # def self.md_2_manpage( md )
+      #   markdown = Redcarpet::Markdown.new( 
+      #     Redcarpet::Render::ManPage, 
+      #     autolink: true, 
+      #     fenced_code_blocks: true,
+      #     tables: true, 
+      #     strikethrough: true )
+          
+      #   return markdown.render( md )
+      # end
+
     end
   end
 end

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
       # ---------------------------------------------------------------------

data/lib/gloo/objs/data/table.rb

@@ -13,6 +13,8 @@ module Gloo
       KEYWORD_SHORT = 'tbl'.freeze
       HEADERS = 'headers'.freeze
       DATA = 'data'.freeze
+      CELLS = 'cells'.freeze
+      STYLES = 'styles'.freeze
 
       #
       # The name of the object type.
@@ -58,12 +60,64 @@ module Gloo
         return [] unless o
 
         o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        cols = self.columns
-        return o.children.map do |e|
-          cols.map { |h| e.find_child( h ).value }
+        
+        if o.is_a? Gloo::Objs::Query
+          @engine.log.debug "Table getting data from query."
+          begin
+            result = o.run_query
+            return result
+          rescue => e
+            @engine.err e.message
+            return nil
+          end
+        else
+          cols = self.columns
+
+          if o.children&.first.children.empty?
+            # It is a simgle row table.
+            rows = [ cols.map { |h| o.find_child( h )&.value } ]
+          else
+            rows = o.children.map do |e|
+              cols.map { |h| e.find_child( h )&.value }
+            end
+          end
+
+          return [ cols, rows ]
         end
       end
 
+      # 
+      # Get the styles for the table, if any.
+      # 
+      def styles
+        style_h = {} 
+        o = find_child STYLES
+        return style_h unless o
+        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
+
+        o.children.each do |c|
+          style_h[ c.name ] = c.value
+        end
+
+        return style_h
+      end
+
+      # 
+      # Get cell renderer hash keyed by column name.
+      # 
+      def cell_renderers
+        h = {}
+        o = find_child CELLS
+        return h unless o
+
+        o.children.each do |c|
+          h[ c.name ] = c.value
+        end
+
+        return h
+      end
+
+
       # ---------------------------------------------------------------------
       #    Children
       # ---------------------------------------------------------------------
@@ -88,6 +142,7 @@ module Gloo
         fac.create_can DATA, self
       end
 
+
       # ---------------------------------------------------------------------
       #    Messages
       # ---------------------------------------------------------------------
@@ -96,7 +151,7 @@ module Gloo
       # Get a list of message names that this object receives.
       #
       def self.messages
-        return super + %w[show]
+        return super + %w[show render]
       end
 
       #
@@ -107,6 +162,90 @@ module Gloo
         @engine.platform.show_table headers, data, title
       end
 
+      def msg_render
+        return render
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Render
+      # ---------------------------------------------------------------------
+
+      # 
+      # Render the table.
+      # The render_ƒ is 'render_html', 'render_text', 'render_json', etc.
+      # 
+      def render render_ƒ
+        begin
+          result = self.data
+          head = self.headers 
+          head = result[0] if head.empty?
+          rows = result[1]
+
+          columns = build_columns result[0]
+
+          params = { 
+            head: head, 
+            cols: result[0],
+            columns: columns,
+            rows: rows,
+            styles: self.styles,
+            cell_renderers: self.cell_renderers
+          }
+
+          helper = Gloo::WebSvr::TableRenderer.new( @engine )
+          return helper.data_to_table params
+        rescue => e
+          @engine.err e.message
+          return nil
+        end
+      end
+
+      # 
+      # Build the column list based on the result data and
+      # the headers defined in the table object.
+      # 
+      def build_columns result_data
+        head_children = find_child HEADERS
+        cell_renderers = find_child CELLS
+
+        columns = []
+        return columns unless result_data
+        
+        result_data.each_with_index do |c,index|
+          visible = true
+          name = c
+          title = c
+          display_index = index
+
+          if head_children
+            child = head_children.find_child c
+            if child
+              title = child.value
+              display_index = head_children.child_index( c )
+            else
+              visible = false
+            end
+          end
+
+          cell_renderer = nil
+          if cell_renderers
+            this_cr = cell_renderers.find_child( c )
+            cell_renderer = this_cr.value if this_cr
+          end
+
+          columns << { 
+            name: name, 
+            title: title, 
+            visible: visible, 
+            data_index: index,
+            display_index: display_index,
+            cell_renderer: cell_renderer
+          }
+        end
+        return columns.sort_by { |hsh| hsh[ :display_index ] }
+      end
+
     end
   end
 end

data/lib/gloo/objs/web/json.rb

@@ -63,6 +63,8 @@ module Gloo
       # Make the JSON pretty.
       #
       def msg_pretty
+        return unless self.value
+
         json = JSON.parse( self.value )
         pretty = JSON.pretty_generate( json )
         set_value pretty

data/lib/gloo/objs/web_svr/element.rb

@@ -173,7 +173,7 @@ module Gloo
       # Get the expiration date for the certificate.
       #
       def msg_render
-        content = self.render
+        content = self.render_html
         @engine.heap.it.set_to content 
         return content
       end
@@ -226,10 +226,9 @@ module Gloo
             e = Gloo::Objs::Alias.resolve_alias( engine, e )
             if e.class == Element
               rendered_obj_content << e.send( render_ƒ )
-            elsif e.class == Partial
-              rendered_obj_content << e.render( render_ƒ )
             else
-              rendered_obj_content << e.value.to_s
+              data = render_thing e, render_ƒ, engine
+              ( rendered_obj_content << data ) if data # e.render( render_ƒ )
             end
           end
         else
@@ -238,7 +237,16 @@ module Gloo
 
         return rendered_obj_content
       end
-                    
+
+      def self.render_thing e, render_ƒ, engine
+        begin
+          return e.render( render_ƒ )
+        rescue => e
+          engine.err e.message
+          return ''
+        end
+      end
+  
     end
   end
 end

data/lib/gloo/objs/web_svr/page.rb

@@ -17,6 +17,7 @@ module Gloo
 
       # Parameters used during render.
       PARAMS = 'params'.freeze
+      ID = 'id'.freeze
 
       # Content
       HEAD = 'head'.freeze
@@ -112,6 +113,19 @@ module Gloo
         params_can = find_child PARAMS
         return nil unless params_can
 
+        if @request
+          url_params = @request.query_params
+          url_params.each do |k,v|
+            o = params_can.find_child k
+            o.set_value( v ) if o
+          end
+
+          @request.body_params.each do |k,v|
+            o = params_can.find_child k
+            o.set_value( v ) if o
+          end
+        end
+
         h = {}
         params_can.children.each do |o|
           h[ o.name ] = o.value
@@ -182,6 +196,8 @@ module Gloo
         o = find_child ON_RENDER
         return unless o
 
+        @engine.log.debug "running on_render for page"
+
         Gloo::Exec::Dispatch.message( @engine, 'run', o )
       end
 
@@ -192,6 +208,8 @@ module Gloo
         o = find_child ON_RENDERED
         return unless o
 
+        @engine.log.debug "running on_rendered for page"
+
         Gloo::Exec::Dispatch.message( @engine, 'run', o )
       end
 
@@ -281,13 +299,36 @@ module Gloo
         return @engine.running_app.obj.redirect
       end
 
+      # 
+      # Set the ID parameter if there is one.
+      # 
+      def set_id
+        return unless @request.id
+        @engine.log.info "Setting ID: #{@request.id}"
+
+        params_can = find_child PARAMS
+        return nil unless params_can
+
+        id_obj = params_can.find_child( ID )
+        return unless id_obj
+
+        id_obj.set_value( @request.id )
+      end
+
       # 
       # Render the page.
+      # If this is being called from the web server,
+      # the request will be passed in and will include
+      # request context such as params.
       # 
-      def render
+      def render request=nil
+        @request = request
+        set_id if @request
+
         run_on_render
         return nil if redirect_set?
 
+        # Set Params before running on render
         params = params_hash
 
         if is_html?
@@ -300,8 +341,9 @@ module Gloo
           @engine.log.error "Unknown content type: #{content_type}"
           return nil
         end
-        
+
         run_on_rendered
+        @request = nil
         return nil if redirect_set?
 
         return contents

data/lib/gloo/objs/web_svr/partial.rb

@@ -161,8 +161,13 @@ module Gloo
         run_on_render
 
         part_content = ''
-        content.children.each do |e|
-          part_content << e.send( render_ƒ )
+        data = content
+        if data.children.empty?
+          part_content = data.value
+        else
+          data.children.each do |e|
+            part_content << e.send( render_ƒ )
+          end
         end
       
         # part_content = Page.render_params part_content, params_hash