otto 1.6.0 → 2.0.0.pre1

data/lib/otto/mcp/route_parser.rb

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
+
+# lib/otto/mcp/route_parser.rb
+
 class Otto
   module MCP
+    # Parser for MCP route definitions and resource URIs
     class RouteParser
       def self.parse_mcp_route(_verb, _path, definition)
         # MCP route format: MCP resource_uri HandlerClass.method_name
         # Note: The path parameter is ignored for MCP routes - resource_uri comes from definition
         parts = definition.split(/\s+/, 3)
 
-        if parts[0] != 'MCP'
-          raise ArgumentError, "Expected MCP keyword, got: #{parts[0]}"
-        end
+        raise ArgumentError, "Expected MCP keyword, got: #{parts[0]}" if parts[0] != 'MCP'
 
         resource_uri       = parts[1]
         handler_definition = parts[2]
 
-        unless resource_uri && handler_definition
-          raise ArgumentError, "Invalid MCP route format: #{definition}"
-        end
+        raise ArgumentError, "Invalid MCP route format: #{definition}" unless resource_uri && handler_definition
 
         # Clean up URI - remove leading slash if present since MCP URIs are relative
         resource_uri = resource_uri.sub(%r{^/}, '')
@@ -33,16 +34,12 @@ class Otto
         # Note: The path parameter is ignored for TOOL routes - tool_name comes from definition
         parts = definition.split(/\s+/, 3)
 
-        if parts[0] != 'TOOL'
-          raise ArgumentError, "Expected TOOL keyword, got: #{parts[0]}"
-        end
+        raise ArgumentError, "Expected TOOL keyword, got: #{parts[0]}" if parts[0] != 'TOOL'
 
         tool_name          = parts[1]
         handler_definition = parts[2]
 
-        unless tool_name && handler_definition
-          raise ArgumentError, "Invalid TOOL route format: #{definition}"
-        end
+        raise ArgumentError, "Invalid TOOL route format: #{definition}" unless tool_name && handler_definition
 
         # Clean up tool name - remove leading slash if present
         tool_name = tool_name.sub(%r{^/}, '')
@@ -70,9 +67,7 @@ class Otto
         # First part is the handler class.method
         parts[1..-1]&.each do |part|
           key, value = part.split('=', 2)
-          if key && value
-            options[key.to_sym] = value
-          end
+          options[key.to_sym] = value if key && value
         end
 
         options

data/lib/otto/mcp/server.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# lib/otto/mcp/server.rb
+
 require_relative 'protocol'
 require_relative 'registry'
 require_relative 'route_parser'
@@ -7,6 +11,7 @@ require_relative 'rate_limiting'
 
 class Otto
   module MCP
+    # MCP server implementation providing Model Context Protocol endpoints
     class Server
       attr_reader :protocol, :otto_instance
 
@@ -68,10 +73,10 @@ class Otto
         end
 
         # Configure validation last (most expensive)
-        if @enable_validation
-          @otto_instance.use Otto::MCP::ValidationMiddleware
-          Otto.logger.debug '[MCP] Request validation enabled' if Otto.debug
-        end
+        return unless @enable_validation
+
+        @otto_instance.use Otto::MCP::ValidationMiddleware
+        Otto.logger.debug '[MCP] Request validation enabled' if Otto.debug
       end
 
       def add_mcp_endpoint_route
@@ -106,11 +111,16 @@ class Otto
 
         # Create resource handler
         handler = lambda do
-            klass = Object.const_get(klass_name)
-            klass.public_send(method_name)
-        rescue StandardError => ex
-            Otto.logger.error "[MCP] Resource handler error for #{uri}: #{ex.message}"
-            raise
+          klass = Object.const_get(klass_name)
+          method = klass.method(method_name)
+          if method.arity != 0
+            raise ArgumentError, "Handler #{klass_name}.#{method_name} must be a zero-arity method for resource #{uri}"
+          end
+
+          klass.public_send(method_name)
+        rescue StandardError => e
+          Otto.logger.error "[MCP] Resource handler error for #{uri}: #{e.message}"
+          raise
         end
 
         # Register with protocol registry
@@ -119,7 +129,7 @@ class Otto
           extract_name_from_uri(uri),
           "Resource: #{uri}",
           'text/plain',
-          handler,
+          handler
         )
 
         Otto.logger.debug "[MCP] Registered resource: #{uri} -> #{handler_def}" if Otto.debug
@@ -146,7 +156,7 @@ class Otto
           name,
           "Tool: #{name}",
           input_schema,
-          "#{klass_name}.#{method_name}",
+          "#{klass_name}.#{method_name}"
         )
 
         Otto.logger.debug "[MCP] Registered tool: #{name} -> #{handler_def}" if Otto.debug

data/lib/otto/mcp/validation.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# lib/otto/mcp/validation.rb
+
 require 'json'
 
 begin
@@ -10,6 +14,7 @@ class Otto
   module MCP
     class ValidationError < StandardError; end
 
+    # JSON Schema validator for MCP protocol requests
     class Validator
       def initialize
         @schemas                = {}
@@ -48,7 +53,7 @@ class Otto
 
       def mcp_request_schema
         @schemas[:mcp_request] ||= JSONSchemer.schema({
-          type: 'object',
+                                                        type: 'object',
           required: %w[jsonrpc method id],
           properties: {
             jsonrpc: { const: '2.0' },
@@ -57,11 +62,11 @@ class Otto
             params: { type: 'object' },
           },
           additionalProperties: false,
-        },
-                                                     )
+                                                      })
       end
     end
 
+    # Middleware for validating MCP protocol requests using JSON schema
     class ValidationMiddleware
       def initialize(app, _security_config = nil)
         @app       = app
@@ -82,10 +87,10 @@ class Otto
 
             # Reset body for downstream middleware
             request.body.rewind if request.body.respond_to?(:rewind)
-          rescue JSON::ParserError => ex
-            return validation_error_response(nil, "Invalid JSON: #{ex.message}")
-          rescue ValidationError => ex
-            return validation_error_response(data&.dig('id'), ex.message)
+          rescue JSON::ParserError => e
+            return validation_error_response(nil, "Invalid JSON: #{e.message}")
+          rescue ValidationError => e
+            return validation_error_response(data&.dig('id'), e.message)
           end
         end
 
@@ -102,15 +107,14 @@ class Otto
 
       def validation_error_response(id, message)
         body = JSON.generate({
-          jsonrpc: '2.0',
+                               jsonrpc: '2.0',
           id: id,
           error: {
             code: -32_600,
             message: 'Invalid Request',
             data: message,
           },
-        },
-                            )
+                             })
 
         [400, { 'content-type' => 'application/json' }, [body]]
       end

data/lib/otto/response_handlers/auto.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'json'
+require_relative 'redirect'
+require_relative 'view'
+require_relative 'default'
+
+class Otto
+  module ResponseHandlers
+    # Auto-detection handler that chooses appropriate handler based on context
+    class AutoHandler < BaseHandler
+      def self.handle(result, response, context = {})
+        # Auto-detect based on result type and request context
+        handler_class = detect_handler_type(result, response, context)
+        handler_class.handle(result, response, context)
+      end
+
+      def self.detect_handler_type(result, response, context)
+        # Check if response type was already set by the handler
+        content_type = response['Content-Type']
+
+        if content_type&.include?('application/json')
+          JSONHandler
+        elsif (context[:logic_instance]&.respond_to?(:redirect_path) && context[:logic_instance].redirect_path) ||
+              (result.is_a?(String) && result.match?(%r{^/}))
+          # Logic instance has redirect path or result is a string path
+          RedirectHandler
+        elsif result.is_a?(Hash)
+          JSONHandler
+        elsif context[:logic_instance]&.respond_to?(:view)
+          ViewHandler
+        else
+          DefaultHandler
+        end
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Otto
+  module ResponseHandlers
+    # Base response handler class
+    class BaseHandler
+      def self.handle(result, response, context = {})
+        raise NotImplementedError, 'Subclasses must implement handle method'
+      end
+
+      def self.ensure_status_set(response, default_status = 200)
+        response.status = default_status unless response.status && response.status != 0
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/default.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class Otto
+  module ResponseHandlers
+    # Default handler that preserves existing Otto behavior
+    class DefaultHandler < BaseHandler
+      def self.handle(_result, response, _context = {})
+        # Otto's default behavior - let the route handler manage the response
+        # This handler does nothing, preserving existing behavior
+        ensure_status_set(response, 200)
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/factory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'json'
+require_relative 'redirect'
+require_relative 'view'
+require_relative 'auto'
+require_relative 'default'
+
+class Otto
+  module ResponseHandlers
+    # Factory for creating response handlers
+    class HandlerFactory
+      # Map of response type names to handler classes
+      HANDLER_MAP = {
+        'json' => JSONHandler,
+        'redirect' => RedirectHandler,
+        'view' => ViewHandler,
+        'auto' => AutoHandler,
+        'default' => DefaultHandler,
+      }.freeze
+
+      def self.create_handler(response_type)
+        handler_class = HANDLER_MAP[response_type.to_s.downcase]
+
+        unless handler_class
+          Otto.logger.warn "Unknown response type: #{response_type}, falling back to default" if Otto.debug
+          handler_class = DefaultHandler
+        end
+
+        handler_class
+      end
+
+      def self.handle_response(result, response, response_type, context = {})
+        handler = create_handler(response_type)
+        handler.handle(result, response, context)
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/json.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class Otto
+  module ResponseHandlers
+    # Handler for JSON responses
+    class JSONHandler < BaseHandler
+      def self.handle(result, response, context = {})
+        response['Content-Type'] = 'application/json'
+
+        # Determine the data to serialize
+        data = if context[:logic_instance]&.respond_to?(:response_data)
+                 context[:logic_instance].response_data
+               elsif result.is_a?(Hash)
+                 result
+               elsif result.nil?
+                 { success: true }
+               else
+                 { success: true, data: result }
+               end
+
+        response.body = [JSON.generate(data)]
+        ensure_status_set(response, context[:status_code] || 200)
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/redirect.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class Otto
+  module ResponseHandlers
+    # Handler for redirect responses
+    class RedirectHandler < BaseHandler
+      def self.handle(result, response, context = {})
+        # Determine redirect path
+        path = if context[:redirect_path]
+                 context[:redirect_path]
+               elsif context[:logic_instance]&.respond_to?(:redirect_path)
+                 context[:logic_instance].redirect_path
+               elsif result.is_a?(String)
+                 result
+               else
+                 '/'
+               end
+
+        response.redirect(path)
+      end
+    end
+  end
+end

data/lib/otto/response_handlers/view.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class Otto
+  module ResponseHandlers
+    # Handler for view/template responses
+    class ViewHandler < BaseHandler
+      def self.handle(result, response, context = {})
+        if context[:logic_instance]&.respond_to?(:view)
+          response.body = [context[:logic_instance].view.render]
+          response['Content-Type'] = 'text/html' unless response['Content-Type']
+        elsif result.respond_to?(:to_s)
+          response.body = [result.to_s]
+          response['Content-Type'] = 'text/html' unless response['Content-Type']
+        else
+          response.body = ['']
+        end
+
+        ensure_status_set(response, context[:status_code] || 200)
+      end
+    end
+  end
+end

data/lib/otto/response_handlers.rb

@@ -1,141 +1,15 @@
+# frozen_string_literal: true
+
 # lib/otto/response_handlers.rb
 
 class Otto
   module ResponseHandlers
-    # Base response handler class
-    class BaseHandler
-      def self.handle(result, response, context = {})
-        raise NotImplementedError, "Subclasses must implement handle method"
-      end
-
-      protected
-
-      def self.ensure_status_set(response, default_status = 200)
-        response.status = default_status unless response.status && response.status != 0
-      end
-    end
-
-    # Handler for JSON responses
-    class JSONHandler < BaseHandler
-      def self.handle(result, response, context = {})
-        response['Content-Type'] = 'application/json'
-
-        # Determine the data to serialize
-        data = if context[:logic_instance]&.respond_to?(:response_data)
-                 context[:logic_instance].response_data
-               elsif result.is_a?(Hash)
-                 result
-               elsif result.nil?
-                 { success: true }
-               else
-                 { success: true, data: result }
-               end
-
-        response.body = [JSON.generate(data)]
-        ensure_status_set(response, context[:status_code] || 200)
-      end
-    end
-
-    # Handler for redirect responses
-    class RedirectHandler < BaseHandler
-      def self.handle(result, response, context = {})
-        # Determine redirect path
-        path = if context[:redirect_path]
-                 context[:redirect_path]
-               elsif context[:logic_instance]&.respond_to?(:redirect_path)
-                 context[:logic_instance].redirect_path
-               elsif result.is_a?(String)
-                 result
-               else
-                 '/'
-               end
-
-        response.redirect(path)
-      end
-    end
-
-    # Handler for view/template responses
-    class ViewHandler < BaseHandler
-      def self.handle(result, response, context = {})
-        if context[:logic_instance]&.respond_to?(:view)
-          response.body = [context[:logic_instance].view.render]
-          response['Content-Type'] = 'text/html' unless response['Content-Type']
-        elsif result.respond_to?(:to_s)
-          response.body = [result.to_s]
-          response['Content-Type'] = 'text/html' unless response['Content-Type']
-        else
-          response.body = ['']
-        end
-
-        ensure_status_set(response, context[:status_code] || 200)
-      end
-    end
-
-    # Default handler that preserves existing Otto behavior
-    class DefaultHandler < BaseHandler
-      def self.handle(result, response, context = {})
-        # Otto's default behavior - let the route handler manage the response
-        # This handler does nothing, preserving existing behavior
-        ensure_status_set(response, 200)
-      end
-    end
-
-    # Auto-detection handler that chooses appropriate handler based on context
-    class AutoHandler < BaseHandler
-      def self.handle(result, response, context = {})
-        # Auto-detect based on result type and request context
-        handler_class = detect_handler_type(result, response, context)
-        handler_class.handle(result, response, context)
-      end
-
-      private
-
-      def self.detect_handler_type(result, response, context)
-        # Check if response type was already set by the handler
-        content_type = response['Content-Type']
-
-        if content_type&.include?('application/json')
-          JSONHandler
-        elsif (context[:logic_instance]&.respond_to?(:redirect_path) && context[:logic_instance]&.redirect_path) ||
-              (result.is_a?(String) && result.match?(%r{^/}))
-          # Logic instance has redirect path or result is a string path
-          RedirectHandler
-        elsif result.is_a?(Hash)
-          JSONHandler
-        elsif context[:logic_instance]&.respond_to?(:view)
-          ViewHandler
-        else
-          DefaultHandler
-        end
-      end
-    end
-
-    # Factory for creating response handlers
-    class HandlerFactory
-      # Map of response type names to handler classes
-      HANDLER_MAP = {
-        'json' => JSONHandler,
-        'redirect' => RedirectHandler,
-        'view' => ViewHandler,
-        'auto' => AutoHandler,
-        'default' => DefaultHandler
-      }.freeze
-
-      def self.create_handler(response_type)
-        handler_class = HANDLER_MAP[response_type.to_s.downcase]
-
-        unless handler_class
-          Otto.logger.warn "Unknown response type: #{response_type}, falling back to default" if Otto.debug
-          handler_class = DefaultHandler
-        end
-
-        handler_class
-      end
-
-      def self.handle_response(result, response, response_type, context = {})
-        handler = create_handler(response_type)
-        handler.handle(result, response, context)
-      end
-    end
+    require_relative 'response_handlers/base'
+    require_relative 'response_handlers/json'
+    require_relative 'response_handlers/redirect'
+    require_relative 'response_handlers/view'
+    require_relative 'response_handlers/default'
+    require_relative 'response_handlers/auto'
+    require_relative 'response_handlers/factory'
   end
 end

data/lib/otto/route.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # lib/otto/route.rb
 
 class Otto
@@ -20,6 +22,7 @@ class Otto
   #
   #
   class Route
+    # Class methods for Route providing Otto instance access
     module ClassMethods
       attr_accessor :otto
     end
@@ -86,7 +89,6 @@ class Otto
 
     private
 
-
     # Safely resolve a class name using Object.const_get with security validations
     # This replaces the previous eval() usage to prevent code injection attacks.
     #
@@ -120,8 +122,8 @@ class Otto
 
       begin
         Object.const_get(class_name)
-      rescue NameError => ex
-        raise ArgumentError, "Class not found: #{class_name} - #{ex.message}"
+      rescue NameError => e
+        raise ArgumentError, "Class not found: #{class_name} - #{e.message}"
       end
     end
 
@@ -148,12 +150,10 @@ class Otto
       res            = Rack::Response.new
       req.extend Otto::RequestHelpers
       res.extend Otto::ResponseHelpers
-      res.request    = req
+      res.request = req
 
       # Make security config available to response helpers
-      if otto.respond_to?(:security_config) && otto.security_config
-        env['otto.security_config'] = otto.security_config
-      end
+      env['otto.security_config'] = otto.security_config if otto.respond_to?(:security_config) && otto.security_config
 
       # NEW: Make route definition and options available to middleware and handlers
       env['otto.route_definition'] = @route_definition
@@ -185,7 +185,7 @@ class Otto
       # This replaces the hardcoded execution pattern with a factory approach
       if otto&.route_handler_factory
         handler = otto.route_handler_factory.create_handler(@route_definition, otto)
-        return handler.call(env, extra_params)
+        handler.call(env, extra_params)
       else
         # Fallback to legacy behavior for backward compatibility
         inst = nil
@@ -205,7 +205,7 @@ class Otto
           context = {
             logic_instance: (kind == :instance ? inst : nil),
             status_code: nil,
-            redirect_path: nil
+            redirect_path: nil,
           }
 
           Otto::ResponseHandlers::HandlerFactory.handle_response(result, res, response_type, context)

data/lib/otto/route_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # lib/otto/route_definition.rb
 
 class Otto
@@ -161,24 +163,19 @@ class Otto
     # @param target [String] The target definition (e.g., "TestApp.index")
     # @return [Hash] Hash with :klass_name, :method_name, and :kind
     def parse_target(target)
-      if target.include?('.')
-        klass_name, method_name = target.split('.', 2)
-        { klass_name: klass_name, method_name: method_name, kind: :class }
-      elsif target.include?('#')
-        klass_name, method_name = target.split('#', 2)
-        { klass_name: klass_name, method_name: method_name, kind: :instance }
-      elsif target.match?(/\A[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*\z/)
-        # Namespaced class with implicit method name (class method with same name as class)
-        # E.g., "V2::Logic::Admin::Panel" -> Panel.Panel (class method)
-        # For single word classes like "Logic", it's truly a logic class
-        method_name = target.split('::').last
-        if target.include?('::')
-          # Namespaced class - treat as class method with implicit method name
-          { klass_name: target, method_name: method_name, kind: :class }
-        else
-          # Single word class - treat as logic class
-          { klass_name: target, method_name: method_name, kind: :logic }
-        end
+      case target
+      when /^(.+)\.(.+)$/
+        # Class.method - call class method directly
+        { klass_name: $1, method_name: $2, kind: :class }
+
+      when /^(.+)#(.+)$/
+        # Class#method - instantiate then call instance method
+        { klass_name: $1, method_name: $2, kind: :instance }
+
+      when /^[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*$/
+        # Bare class name - instantiate the class
+        { klass_name: target, method_name: target.split('::').last, kind: :logic }
+
       else
         raise ArgumentError, "Invalid target format: #{target}"
       end