Class: Tina4::Middleware

Inherits:
Object
  • Object
show all
Defined in:
lib/tina4/middleware.rb

Class Method Summary collapse

Class Method Details

.after(pattern = nil, &block) ⇒ Object 



28
29
30
 
# File 'lib/tina4/middleware.rb', line 28

def after(pattern = nil, &block)
  after_handlers << { pattern: pattern, handler: block }
end

.after_handlers ⇒ Object 



10
11
12
 
# File 'lib/tina4/middleware.rb', line 10

def after_handlers
  @after_handlers ||= []
end

.before(pattern = nil, &block) ⇒ Object 



24
25
26
 
# File 'lib/tina4/middleware.rb', line 24

def before(pattern = nil, &block)
  before_handlers << { pattern: pattern, handler: block }
end

.before_handlers ⇒ Object 



6
7
8
 
# File 'lib/tina4/middleware.rb', line 6

def before_handlers
  @before_handlers ||= []
end

.clear! ⇒ Object 



38
39
40
41
42
 
# File 'lib/tina4/middleware.rb', line 38

def clear!
  @before_handlers = []
  @after_handlers = []
  @global_middleware = []
end

.get_global ⇒ Object

Parity alias matching Python/PHP/Node orchestrators.



20
21
22
 
# File 'lib/tina4/middleware.rb', line 20

def get_global
  global_middleware.dup
end

.global_middleware ⇒ Object

Registry of class-based middleware (registered via Router.use)



15
16
17
 
# File 'lib/tina4/middleware.rb', line 15

def global_middleware
  @global_middleware ||= []
end

.run_after(middleware_classes, request, response) ⇒ Object

Run all “after” hooks: block-based handlers, then class-based after_* methods.

Signature matches Python/PHP/Node orchestrators: pass the list of middleware classes explicitly.



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/tina4/middleware.rb', line 80

def run_after(middleware_classes, request, response)
  # 1. Block-based after handlers (pattern-matched)
  after_handlers.each do |entry|
    next unless matches_pattern?(request.path, entry[:pattern])
    entry[:handler].call(request, response)
  end

  # 2. Class-based middleware: call every after_* method
  middleware_classes.each do |klass|
    after_methods_for(klass).each do |method_name|
      result = klass.send(method_name, request, response)
      if result.is_a?(Array) && result.length == 2
        request, response = result
      end
    end
  end
end

.run_before(middleware_classes, request, response) ⇒ Object

Run all “before” hooks: block-based handlers, then class-based before_* methods.

Signature matches Python/PHP/Node orchestrators: pass the list of middleware classes explicitly.

Returns [request, response] on success, or false to halt the request.



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/tina4/middleware.rb', line 50

def run_before(middleware_classes, request, response)
  # 1. Block-based before handlers (pattern-matched)
  before_handlers.each do |entry|
    next unless matches_pattern?(request.path, entry[:pattern])
    result = entry[:handler].call(request, response)
    return false if result == false
  end

  # 2. Class-based middleware: call every before_* method
  middleware_classes.each do |klass|
    before_methods_for(klass).each do |method_name|
      result = klass.send(method_name, request, response)
      # Support returning [request, response] (Python convention) or false to halt
      if result == false
        return false
      elsif result.is_a?(Array) && result.length == 2
        request, response = result
        # If response already has a non-2xx status, halt processing
        return false if response.status_code >= 400
      end
    end
  end

  true
end

.use(klass) ⇒ Object

Register a class-based middleware globally. The class should define static before_* and/or after_* methods.



34
35
36
 
# File 'lib/tina4/middleware.rb', line 34

def use(klass)
  global_middleware << klass unless global_middleware.include?(klass)
end