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 



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

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 



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

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 



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

def clear!
  @before_handlers = []
  @after_handlers = []
  @global_middleware = []
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(request, response) ⇒ Object

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



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/tina4/middleware.rb', line 68

def run_after(request, response)
  # 1. Block-based after handlers (backward compat)
  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
  global_middleware.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(request, response) ⇒ Object

Run all “before” hooks: block-based handlers, then class-based before_* methods. Returns [request, response] on success, or false to halt the request.



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/tina4/middleware.rb', line 41

def run_before(request, response)
  # 1. Block-based before handlers (backward compat)
  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
  global_middleware.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.



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

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