gloo 4.7.0 → 5.0.1

data/lib/gloo/web_svr/request_params.rb

@@ -1,181 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
-#
-# A Parameters associated with a request.
-#
-# Kinds of Params
-#   Id - The entity id
-#   Key - URL parameter key
-#   URL Params - Parameters in the URL
-#   Body Params - Data from the body of the request
-# 
-
-module Gloo
-  module WebSvr
-    class RequestParams
-
-      attr_accessor :id, :route_params
-      attr_reader :query_params, :body_params, :body_binary
-      
-      # ---------------------------------------------------------------------
-      #    Initialization
-      # ---------------------------------------------------------------------
-
-      #
-      # Set up the web server.
-      #
-      def initialize( log )
-        @log = log
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Value Detection
-      # ---------------------------------------------------------------------
-
-      # 
-      # Detect the parameters from query string.
-      # 
-      def init_query_params query_string
-        if query_string
-          @query_params = Rack::Utils.parse_query( query_string )
-        else
-          @query_params = {} 
-        end
-      end
-
-      # 
-      # Detect the parameters from the body of the request.
-      # 
-      def init_body_params body
-        if body && body.length > 0
-          # if body is binary, then it is not a query string
-          begin
-            @body_params = Rack::Utils.parse_query body
-          rescue => exception
-            init_multipart body 
-          end
-        else
-          @body_params = {} 
-        end
-      end
-
-      # 
-      # Set the body to a binary file.
-      # 
-      # TODO: find a lib or method to handle this.
-      # This is very rough and will need to be fixed.
-      # 
-      def init_multipart body
-        # puts "*********** first lines: *********** "
-        # body.lines[0..3].each { |line| puts line }
-        # puts "*********** last lines: *********** "
-        # body.lines.last(5).each { |line| puts line }
-        # puts "************************************"
-
-        # boundary = body.lines.first
-        # puts "boundary: #{boundary}"
-
-        header = body.lines[1..3].join
-        # puts "header: #{header}"
-
-        footer = body.lines.last(5).join
-        # puts "footer: #{footer}"
-
-        binary_data = body.lines[4..-6].join
-        # puts "binary_data length: #{binary_data.length}"
-        # puts "binary first line: #{binary_data.lines.first}"
-        # puts "binary last line: #{binary_data.lines.last}"
-
-        i = header.lines.first.index( 'filename=' )
-        filename = header.lines.first[ i+10..-4 ]
-        content_type = header.lines.second[14..-3]
-        # puts "filename: #{filename}"
-        # puts "content_type: #{content_type}"
-
-        @body_binary = body
-        @body_params = {}
-        @body_params[ 'content_type' ] = content_type
-        @body_params[ 'file_name' ] = filename
-        @body_params[ 'file_size' ] = binary_data.length
-        @body_params[ 'file_data' ] = binary_data
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Authenticity Token checking
-      # ---------------------------------------------------------------------
-
-      # 
-      # Check the authenticity token if it is present.
-      # Returns true if it is present and valid, and
-      # also if it is not present.
-      # Returns false if it is present but not valid.
-      # 
-      def check_authenticity_token engine
-        auth_token = @query_params[ Gloo::Objs::CsrfToken::AUTHENTICITY_TOKEN ]
-        if auth_token
-          session_id = engine.running_app.obj&.session&.get_session_id
-          return false unless session_id
-
-          return Gloo::Objs::CsrfToken.valid_csrf_token?( session_id, auth_token )
-        end
-
-        return true
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Helper functions
-      # ---------------------------------------------------------------------
-
-      # 
-      # Check the body to see if there is a PATCH or a PUT in 
-      # the method override.
-      # 
-      def get_body_method_override orig_method
-        if @body_params[ '_method' ]
-          return @body_params[ '_method' ].upcase
-        end
-        return orig_method
-      end
-
-      # 
-      # Write the querey and body params to the log.
-      # 
-      def log_params
-        return unless @log
-
-        if @query_params && ! @query_params.empty?
-          @log.info "--- Query Parameters: #{@query_params}" 
-        end
-
-        if @body_params && ! @body_params.empty?
-          if @body_params[ 'file_data' ]
-            # exclude the file data from the params shown
-            params = @body_params.dup
-            params.delete( 'file_data' )
-            params[ 'file_data' ] = '...'
-            @log.info "--- Body Parameters: #{params}"
-          else
-            @log.info "--- Body Parameters: #{@body_params}"
-          end
-        end
-      end
-
-      # 
-      # Write the id and route params to the log.
-      # 
-      def log_id_keys
-        return unless @log
-
-        @log.info "--- ID Parameter: #{@id}" if @id
-
-        if @route_params && ! @route_params.empty?
-          @log.info "--- Route Parameters: #{@route_params}"
-        end
-      end
-
-    end
-  end
-end

data/lib/gloo/web_svr/response.rb

@@ -1,177 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
-#
-# The Response for a web Request.
-#
-
-module Gloo
-  module WebSvr
-    class Response
-
-      # 
-      # SEE: https://stackoverflow.com/questions/23714383/what-are-all-the-possible-values-for-http-content-type-header#48704300
-      #  for a list of content types.
-      # 
-      CONTENT_TYPE = 'Content-Type'.freeze
-      TEXT_TYPE = 'text/plain'.freeze
-      JSON_TYPE = 'application/json'.freeze
-      HTML_TYPE = 'text/html'.freeze
-            
-      attr_reader :code, :type, :data
-      attr_accessor :location
-      attr_accessor :file_name
-      
-
-      # ---------------------------------------------------------------------
-      #    Initialization
-      # ---------------------------------------------------------------------
-
-      #
-      # Set up the web server.
-      #
-      def initialize( engine = nil, 
-        code = Gloo::WebSvr::ResponseCode::SUCCESS, 
-        type = HTML_TYPE, 
-        data = nil,
-        assetCache = false,
-        file_name = nil,
-        download = false )
-        
-        @engine = engine
-        @log = @engine.log if @engine
-
-        @code = code
-        @type = type
-        @data = data
-        @assetCache = assetCache
-        @location = nil
-        @file_name = file_name
-        @download = download
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Static Helper Functions
-      # ---------------------------------------------------------------------
-
-      # 
-      # Helper to create a successful JSON response with the given data.
-      # 
-      def self.json_response( engine, data, 
-        code = Gloo::WebSvr::ResponseCode::SUCCESS )
-
-        return Gloo::WebSvr::Response.new( engine, code, JSON_TYPE, data )
-      end
-
-      # 
-      # Helper to create a successful text response with the given data.
-      # 
-      def self.text_response( engine, data, 
-        code = Gloo::WebSvr::ResponseCode::SUCCESS )
-
-        return Gloo::WebSvr::Response.new( engine, code, TEXT_TYPE, data )
-      end
-
-      # 
-      # Helper to create a successful web response with the given data.
-      # 
-      def self.html_response( engine, data, 
-        code = Gloo::WebSvr::ResponseCode::SUCCESS )
-
-        return Gloo::WebSvr::Response.new( engine, code, HTML_TYPE, data )
-      end
-
-      # 
-      # Helper to create a redirect response.
-      # 
-      def self.redirect_response( engine, target )
-        code = Gloo::WebSvr::ResponseCode::FOUND
-        data = <<~TEXT
-        <head>
-          <html>
-            <body><a href="#{target}">target is here</a></body>
-          </html>
-        </head>
-        TEXT
-
-        response = Gloo::WebSvr::Response.new( engine, code, HTML_TYPE, data )
-        response.location = target
-
-        return response
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Data Functions
-      # ---------------------------------------------------------------------
-
-      # 
-      # Add content to the payload.
-      # 
-      def add content
-        @data = '' if @data.nil?
-        @data << content
-      end
-
-      # 
-      # Get the headers for the response.
-      # 
-      def headers
-        # 
-        # TO DO: Add more cookie headers here.
-        # 
-        #  https://stackoverflow.com/questions/3295083/how-do-i-set-a-cookie-with-a-ruby-rack-middleware-component
-        #   https://www.rubydoc.info/gems/rack/1.4.7/Rack/Session/Cookie
-        #
-
-        headers = { CONTENT_TYPE => @type }
-
-        if @location
-          headers[ 'Location' ] = @location
-        end
-
-        if @assetCache || @file_name
-          headers[ 'Cache-Control' ] = 'public, max-age=604800'
-          headers[ 'Expires' ] = (Time.now.utc + 604800).to_s
-        end
-
-        if @file_name
-          disp = @download ? 'attachment' : 'inline'
-          headers[ 'Content-Disposition' ] = "#{disp}; filename=#{@file_name}"
-          headers[ 'Content-Length' ] = @data.length.to_s
-        end
-
-        session = @engine&.running_app&.obj&.session
-        headers = session.add_session_for_response( headers ) if session
-  
-        # Clear out session data after the response is prepared.
-        @engine&.running_app&.obj&.reset_session_data
-
-        return headers
-      end
-
-      # 
-      # Get the final result that will be returned as the 
-      # response to the web request.
-      # 
-      def result
-        return [ @code, headers, @data ]
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Helper functions
-      # ---------------------------------------------------------------------
-
-      # 
-      # Write the result information to the log.
-      # 
-      def log
-        return unless @log
-
-        @log.info "Response #{@code} #{@type}"
-      end
-
-    end
-  end
-end

data/lib/gloo/web_svr/response_code.rb

@@ -1,69 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
-#
-# Standard Response Codes.
-# 
-# See:
-#    https://en.wikipedia.org/wiki/List_of_HTTP_status_codes 
-#    https://www.geeksforgeeks.org/10-most-common-http-status-codes/
-# 
-
-module Gloo
-  module WebSvr
-    class ResponseCode
-
-      # Gloo::WebSvr::ResponseCode::SUCCESS
-      SUCCESS = 200.freeze
-      CODE_200 = 'Success/OK'.freeze
-
-      CREATED = 201.freeze
-      CODE_201 = 'Created'.freeze
-
-      ACCEPTED = 202.freeze
-      CODE_202 = 'Accepted'.freeze
-
-      NO_CONTENT = 204.freeze
-      CODE_204 = 'No Content'.freeze
-
-      PARTIAL_CONTENT = 206.freeze
-      CODE_206 = 'Partial Content'.freeze
-
-      MOVED_PERM = 301.freeze
-      CODE_301 = 'Moved Permanently'.freeze
-      
-      FOUND = 302.freeze
-      CODE_302 = 'Found'.freeze
-
-      SEE_OTHER = 303.freeze
-      CODE_303 = 'See Other'.freeze
-
-      NOT_MODIFIED = 304.freeze
-      CODE_304 = 'Not Modified'.freeze
-
-      TEMP_REDIRECT = 307.freeze
-      CODE_307 = 'Temporary Redirect'.freeze
-
-      PERM_REDIRECT = 308.freeze
-      CODE_308 = 'Permanent Redirect'.freeze
-
-      BAD_REQUEST = 400.freeze
-      CODE_400 = 'Bad Request'.freeze
-
-      UNAUTHORIZED = 401.freeze
-      CODE_401 = 'Unauthorized'.freeze
-
-      FORBIDDEN = 403.freeze
-      CODE_403 = 'Forbidden'.freeze
-
-      NOT_FOUND = 404.freeze
-      CODE_404 = 'Not Found'.freeze
-
-      SERVER_ERR = 500.freeze
-      CODE_500 = 'Internal Server Error'.freeze
-
-      NOT_IMPLEMENTED = 501.freeze
-      CODE_501 = 'Not Implemented'.freeze
-
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# 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

@@ -1,232 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2024 Eric Crane.  All rights reserved.
-#
-# A helper class for page routing.
-# 
-
-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
-          route_params = nil
-          @id = nil
-          
-          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, route_params ] 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 ) 
-            
-            # Are there any remaining segments to be added as route parameters?
-            if @route_segments.count > 0
-              route_params = @route_segments
-            end
-
-            return [ page, @id, route_params ] 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
-          # For Assets, substitute the published name with fingerprint
-          # for the simple asset name (if it is found).
-          asset_info = Gloo::WebSvr::AssetInfo.find_info_for( path )
-          unless asset_info.blank?
-            path = asset_info.pn
-          end
-
-          # 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