gloo 3.1.1 → 3.2.0

data/lib/gloo/web_svr/handler.rb

@@ -36,7 +36,9 @@ module Gloo
       def handle request
         @request = request
 
-        page = @server_obj.router.page_for_route @request.path
+        page, id = @server_obj.router.page_for_route( @request.path, @request.method )
+        @engine.log.debug "Found Page: #{page&.name}" if page
+        request.id = id
         if page
           if page.is_a? Gloo::Objs::FileHandle
             return handle_file page
@@ -53,7 +55,7 @@ module Gloo
       # Render the page, with possible redirect.
       # 
       def handle_page page
-        result = page.render
+        result = page.render @request
         if redirect_set?
           page = @engine.running_app.obj.redirect
           @log.debug "Redirecting to: #{page.pn}"

data/lib/gloo/web_svr/request.rb

@@ -19,7 +19,8 @@ module Gloo
       HTTP_HOST = 'HTTP_HOST'.freeze
       QUERY_STRING = 'QUERY_STRING'.freeze
 
-      attr_reader :method, :host, :path, :query
+      attr_reader :method, :host, :path, :query, :body
+      attr_accessor :id
 
       
       # ---------------------------------------------------------------------
@@ -66,6 +67,10 @@ module Gloo
         @path = @env[ REQUEST_PATH ]
         @host = @env[ HTTP_HOST ]
         @query = @env[ QUERY_STRING ]
+
+        @body = @env[ 'rack.input' ].read
+        @body = Rack::Utils.parse_query @body
+        check_body_method
       end
 
 
@@ -78,6 +83,7 @@ module Gloo
       # 
       def start_timer
         @start = Time.now
+        @engine.running_app.reset_db_time
       end
     
       # 
@@ -86,7 +92,8 @@ module Gloo
       def finish_timer
         @finish = Time.now
         @elapsed = ( ( @finish - @start ) * 1000.0 ).round(2)
-        @log.info "Web request complete.  Elapsed time: #{@elapsed} ms"
+        db = @engine.running_app.db_time
+        @log.info "*** Web request complete.  DB: #{db} ms.  Elapsed time: #{@elapsed} ms"
       end
     
 
@@ -94,12 +101,38 @@ module Gloo
       #    Helper functions
       # ---------------------------------------------------------------------
 
+      # 
+      # Check the body to see if there is a PATCH or a PUT in 
+      # the method override.
+      # 
+      def check_body_method
+        if @body[ '_method' ]
+          @method = @body[ '_method' ].upcase
+        end
+      end
+
+      #
+      # Get the hash of query parameters.
+      # 
+      def query_params
+        return {} unless @query
+        return Rack::Utils.parse_query( @query )
+      end
+
+      # 
+      # Get the hash of body parameters.
+      # 
+      def body_params
+        return @body ? @body : {}
+      end
+
       # 
       # Write the request information to the log.
       # 
       def log
         @log.info "#{@method} #{@host}#{@path}"
         @log.info "Parameters: #{@query}"
+        @log.info "Body: #{@body}" unless @body.empty?
       end
 
     end

data/lib/gloo/web_svr/routing/resource_router.rb

@@ -0,0 +1,47 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
+#
+# A helper class for Resource routing.
+# 
+
+module Gloo
+  module WebSvr
+    module Routing
+      class ResourceRouter
+        
+        INDEX = 'index'.freeze
+        SHOW = 'show'.freeze
+        DELETE = 'delete'.freeze
+        UPDATE = 'update'.freeze
+
+        POST_ROUTE = 'create'.freeze
+
+
+        # 
+        # Is the given route segment an implicit create resource?
+        # It is explicit if it is 'create' 
+        #  and implicit if it is a POST to the resource.
+        # 
+        def self.is_implicit_create?( method, route_segment )
+          return false unless Gloo::WebSvr::WebMethod.is_post?( method )
+
+          return ! route_segment.eql?( POST_ROUTE )
+        end
+
+        # 
+        # Add the segment based on the method.
+        # 
+        def self.segment_for_method( method ) 
+          if Gloo::WebSvr::WebMethod.is_delete?( method )
+            return DELETE
+          elsif Gloo::WebSvr::WebMethod.is_patch?( method )
+            return UPDATE
+          else
+            return SHOW
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/gloo/web_svr/routing/router.rb

@@ -0,0 +1,218 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# A helper class for page routing.
+# 
+require 'tty-table'
+
+module Gloo
+  module WebSvr
+    module Routing
+      class Router
+        
+        PAGE_CONTAINER = 'page'.freeze
+        SEGMENT_DIVIDER = '/'.freeze
+
+        attr_reader :route_segments
+
+
+        # ---------------------------------------------------------------------
+        #    Initialization
+        # ---------------------------------------------------------------------
+
+        #
+        # Set up the web server.
+        #
+        def initialize( engine, web_svr_obj )
+          @engine = engine
+          @log = @engine.log
+
+          @web_svr_obj = web_svr_obj
+          @show_routes = ShowRoutes.new( @engine )
+        end
+
+
+        # ---------------------------------------------------------------------
+        #    Routing
+        # ---------------------------------------------------------------------
+
+        # 
+        # Find and return the page for the given route.
+        # 
+        def page_for_route( path, method )
+          @log.info "routing to #{path} for method #{method}"
+          @method = method
+          
+          detect_segments path
+
+          return @web_svr_obj.home_page if is_root_path?
+
+          pages = @web_svr_obj.pages_container
+          if pages
+            # If the method is POST and the last segment is NOT 'create',
+            # we'll add create to the route segments.
+            if Gloo::WebSvr::Routing::ResourceRouter.is_implicit_create?( method, @route_segments.last )
+              @route_segments << Gloo::WebSvr::Routing::ResourceRouter::POST_ROUTE
+              page = find_route_segment( pages.children )
+              return [ page, @id ] if page
+
+              # We didn't find the page, so remove the last segment and try again 
+              # posting to the resource.
+              @route_segments.pop
+            end
+
+            page = find_route_segment( pages.children ) 
+            return [ page, @id ] if page
+          end
+
+          return nil
+        end
+
+
+        # ---------------------------------------------------------------------
+        #    Dynamic Add Page Routes
+        # ---------------------------------------------------------------------
+
+        # 
+        # Get the root level page container.
+        #
+        def page_container
+          pn = Gloo::Core::Pn.new( @engine, PAGE_CONTAINER )
+          return pn.resolve
+        end
+
+        # 
+        # Add all page routes to the web server pages (routes).
+        # 
+        def add_page_routes
+          can = page_container
+          return unless can
+
+          @log.debug 'Adding page routes to web server…'
+          @factory = @engine.factory
+
+          add_pages can, @web_svr_obj.pages_container
+        end
+
+        #
+        # Add the pages to the web server pages.
+        # This is a recursive function that will add all
+        # pages in the folder and subfolders.
+        #
+        def add_pages can, parent
+          # for each file in the page container
+          # create a page object and add it to the routes
+          can.children.each do |obj|
+            if obj.class == Gloo::Objs::Container
+              child_can = parent.find_add_child( obj.name, 'container' )
+              add_pages( obj, child_can )
+            elsif obj.class == Gloo::Objs::Page
+              add_route_alias( parent, obj.name, obj.pn )
+            end
+          end
+        end
+
+        # 
+        # Add route alias to the page.
+        # 
+        def add_route_alias( parent, name, pn )
+          name = name.gsub( '.', '_' )
+
+          # First make sure the child doesn't already exist.
+          child = parent.find_child( name )
+          return if child
+
+          @factory.create_alias( name, pn, parent )
+        end
+
+        
+        # ---------------------------------------------------------------------
+        #    Helper funcions
+        # ---------------------------------------------------------------------
+
+        # 
+        # Show the routes in the running app.
+        # This uses the ShowRoutes helper class.
+        #
+        def show_routes
+          @show_routes.show page_container
+        end
+
+        # 
+        # Find the route segment in the object container.
+        # 
+        def find_route_segment objs
+          this_segment = next_segment
+
+          if this_segment.blank? # && Gloo::WebSvr::WebMethod.is_post?( @method )
+            this_segment = Gloo::WebSvr::Routing::ResourceRouter::INDEX 
+          end
+
+          objs.each do |o|
+            o = Gloo::Objs::Alias.resolve_alias( @engine, o )
+
+            if o.name == this_segment
+              if o.class == Gloo::Objs::Page
+                @log.debug "found page for route: #{o.pn}"
+                return o
+              elsif o.class == Gloo::Objs::FileHandle
+                @log.debug "found static file for route: #{o.pn}"
+                return o
+              else
+                return nil unless o.child_count > 0
+
+                return find_route_segment( o.children )
+              end
+            end
+          end
+
+          return nil 
+        end
+
+        # 
+        # Get the next segment in the route.
+        # 
+        def next_segment
+          this_segment = @route_segments.shift
+          return nil if this_segment.nil?
+
+          # A URL might include a dot in a name, but we can't do that
+          # because dot is a reserve path thing. So we replace it with
+          # an underscore.
+          this_segment = this_segment.gsub( '.', '_' )
+
+          return this_segment
+        end
+
+        # 
+        # Is this the root path?
+        def is_root_path?
+          return @route_segments.count == 0
+        end
+
+        # 
+        # Create a list of path segments.
+        # 
+        def detect_segments path
+          # Split the path into segments.
+          @route_segments = path.split SEGMENT_DIVIDER
+
+          # Remove the first segment if it is empty.
+          @route_segments.shift if @route_segments.first.blank?
+
+          @route_segments.each do |seg|
+            if seg.to_i.to_s == seg
+              @id = seg.to_i
+              @log.info "found id for route: #{@id}"
+              @route_segments.delete seg
+              @route_segments << ResourceRouter.segment_for_method( @method )
+            end
+          end
+
+          return @route_segments
+        end
+
+      end
+    end
+  end
+end

data/lib/gloo/web_svr/routing/show_routes.rb

@@ -0,0 +1,98 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# A helper class for to show routes for a running app.
+# 
+require 'tty-table'
+
+module Gloo
+  module WebSvr
+    module Routing
+      class ShowRoutes
+
+        SEGMENT_DIVIDER = '/'.freeze
+        RETURN = "\n".freeze
+
+
+        # ---------------------------------------------------------------------
+        #    Initialization
+        # ---------------------------------------------------------------------
+
+        #
+        # Set up the web server.
+        #
+        def initialize( engine )
+          @engine = engine
+          @log = @engine.log
+        end
+
+        
+        # ---------------------------------------------------------------------
+        #    Show Routes
+        # ---------------------------------------------------------------------
+
+        # 
+        # Show all available routes.
+        # 
+        def show page_container
+          @log.debug "showing routes"
+
+          @found_routes = []
+          @log.debug "building route table"
+          add_container_routes( page_container, SEGMENT_DIVIDER )
+
+          show_table
+        end
+
+        #
+        # Show the routes in the given container.
+        # This is a recursive function travese the object tree.
+        # 
+        def add_container_routes can, route_path
+          can.children.each do |obj|
+            if obj.class == Gloo::Objs::Container
+              add_container_routes obj, "#{route_path}#{obj.name}#{SEGMENT_DIVIDER}"
+            elsif obj.class == Gloo::Objs::Page
+              route = "#{route_path}#{obj.name}"
+              @found_routes << [ obj.name, obj.pn, route, Gloo::WebSvr::WebMethod::GET ]
+
+              # If the method is POST, add a route alias for the create.
+              if obj.name.eql? ResourceRouter::POST_ROUTE
+                @found_routes << [ '', '', route_path, Gloo::WebSvr::WebMethod::POST ]
+              elsif obj.name.eql? ResourceRouter::UPDATE
+                @found_routes << [ '', '', route_path, Gloo::WebSvr::WebMethod::PATCH ]
+              elsif obj.name.eql? ResourceRouter::DELETE
+                @found_routes << [ '', '', route_path, Gloo::WebSvr::WebMethod::DELETE ]
+              end
+            end
+          end
+        end
+
+
+        # ---------------------------------------------------------------------
+        #    Show Routes
+        # ---------------------------------------------------------------------
+
+        # 
+        # Show the Routes title.
+        # 
+        def show_table
+          @log.show "\n\tRoutes in Running Web App\n", :white
+
+          table = TTY::Table.new( headers, @found_routes )
+          renderer = TTY::Table::Renderer::Unicode.new( table, padding: [0,1] )
+          puts renderer.render
+          puts RETURN
+        end
+
+        # 
+        # Get the table headers.
+        # 
+        def headers
+          return [ 'Obj Name', 'Obj Path', 'Route', 'Method' ]
+        end
+
+      end
+    end
+  end
+end

data/lib/gloo/web_svr/server.rb

@@ -34,8 +34,9 @@ module Gloo
       #
       # Set up the web server.
       #
-      def initialize( engine, handler, config = nil )
+      def initialize( engine, handler, config = nil, ssl_config = nil )
         @config = config ? config : Gloo::WebSvr::Config.new
+        @ssl_config = ssl_config
         @engine = engine
         @log = @engine.log
         @handler = handler
@@ -57,7 +58,14 @@ module Gloo
           :Host => @config.host
         }
         Thread.abort_on_exception = true
-        @server_thread = Thread.new { Rack::Handler::Thin.run( self, **options=opts ) }
+        @server_thread = Thread.new { 
+          Rack::Handler::Thin.run( self, **options=opts ) do |server|
+            if @ssl_config
+              server.ssl = true
+              server.ssl_options = @ssl_config
+            end
+          end
+        }
         @log.debug 'Web server has started.'
       end
 

data/lib/gloo/web_svr/table_renderer.rb

@@ -0,0 +1,147 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 20124 Eric Crane.  All rights reserved.
+#
+# A helper class used to render HTML tables.
+# 
+
+module Gloo
+  module WebSvr
+    class TableRenderer
+
+      TABLE = 'table'.freeze
+      THEAD = 'thead'.freeze
+      HEAD_CELL = 'head_cell'.freeze
+      ROW = 'row'.freeze
+      CELL = 'cell'.freeze
+
+      # ---------------------------------------------------------------------
+      #    Initialization
+      # ---------------------------------------------------------------------
+
+      #
+      # Set up the web server.
+      #
+      def initialize( engine )
+        @engine = engine
+        @log = @engine.log
+      end
+
+
+      # ---------------------------------------------------------------------
+      #    Container Renderer
+      # ---------------------------------------------------------------------
+
+      # 
+      # Render the query result set to an HTML table.
+      # 
+      # params = { 
+      #   head: head, 
+      #   cols: result[0],
+      #   rows: rows,
+      #   styles: self.styles,
+      #   cell_renderers: self.cell_renderers
+      # }
+      # 
+      def data_to_table params
+        data = params[ :rows ]
+        
+        if data.nil? || ( data.length == 0 )
+          return "<p>No data found.</p>"
+        elsif data.length == 1
+          return data_to_single_row_table( params )
+        else
+          return data_to_table_rows( params )
+        end
+      end
+
+      # 
+      # Show in single-row (form) format.
+      # 
+      def data_to_single_row_table( params )
+        styles = params[ :styles ]
+        str = "<table class='#{styles[ TABLE ]}'> <tbody>"
+        row = params[ :rows ].first
+        
+        params[ :columns ].each do |head|
+          next unless head[ :visible ]
+          cell = row[ head[ :data_index ] ]
+
+          if head[ :cell_renderer ]
+            cell_value = render_cell( row, head, params[ :columns ] )
+          else
+            cell_value = cell
+          end
+
+          str += "<tr class='#{styles[ ROW ]}'>"
+          str += "<th style='#{styles[ HEAD_CELL ]}'>#{head[ :title ]}</th>"
+          str += "<td style='#{styles[ CELL ]}'>#{cell_value}</td>"
+          str += "</tr>"
+        end
+
+        str += "</tbody></table>"
+        return str
+      end
+
+      # 
+      # Show in normal, multi-row format.
+      # 
+      def data_to_table_rows( params )
+        styles = params[ :styles ]
+        # headers = params[ :head ]
+
+        str = "<table class='#{styles[ TABLE ]}'>"
+        str << "<thead class='#{styles[ THEAD ]}'><tr>"
+
+        params[ :columns ].each do |head|
+          next unless head[ :visible ]
+          str += "<th class='#{styles[ HEAD_CELL ]}'>#{head[ :title ]}</th>"
+        end
+        str << "</tr></thead><tbody>"
+
+        params[ :rows ].each do |row|
+          str += "<tr class='#{styles[ ROW ]}'>"
+
+          # row.each_with_index do |cell, i|
+          params[ :columns ].each do |head|
+            next unless head[ :visible ]
+
+            cell = row[ head[ :data_index ] ]
+            this_col_name = head[ :name ]
+
+            if head[ :cell_renderer ]
+              cell_value = render_cell( row, head, params[ :columns ] )
+            else
+              cell_value = cell
+            end
+            str += "<td style='#{styles[ CELL ]}'>#{cell_value}</td>"
+          end
+          str += "</tr>"
+        end
+        str += "</tbody></table>"
+
+        return str
+      end
+
+      # 
+      # Render a cell using the cell renderer and the given
+      # context data (the row's values).
+      # 
+      def render_cell row, col, cols
+        params = {}
+
+        cols.each_with_index do |c, i|
+          params[ c[ :name ] ] = row[ c[ :data_index ] ]
+        end
+      
+        content = col[ :cell_renderer ]
+        content = @engine.running_app.obj.embedded_renderer.render content, params
+
+        # renderer = ERB.new( col[ :cell_renderer ] )
+        # content = renderer.result_with_hash( params )
+      
+        return content
+      end
+    end
+    
+  end
+end

data/lib/gloo/web_svr/web_method.rb

@@ -0,0 +1,54 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
+#
+# A helper class for Web Methods.
+# 
+
+module Gloo
+  module WebSvr
+    class WebMethod
+
+      GET = 'GET'.freeze
+      POST = 'POST'.freeze
+      PUT = 'PUT'.freeze
+      DELETE = 'DELETE'.freeze
+      PATCH = 'PATCH'.freeze
+
+      # 
+      # Is the method a GET?
+      # 
+      def self.is_get?( method )
+        return method.upcase == GET
+      end
+
+      # 
+      # Is the method a POST?
+      # 
+      def self.is_post?( method )
+        return method.upcase == POST
+      end
+
+      # 
+      # Is the method a PUT?
+      # 
+      def self.is_put?( method )
+        return method.upcase == PUT
+      end
+
+      # 
+      # Is the method a PATCH?
+      # 
+      def self.is_patch?( method )
+        return method.upcase == PATCH
+      end
+
+      # 
+      # Is the method a DELETE?
+      # 
+      def self.is_delete?( method )
+        return method.upcase == DELETE
+      end
+
+    end
+  end
+end