Class: ConvenientService::Dependencies::Extractions::RubyMiddleware::Middleware::Builder

Inherits:
Object
  • Object
show all
Defined in:
lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb

Overview

This provides a DSL for building up a stack of middlewares.

This code is based heavily off of Rack::Builder and ActionDispatch::MiddlewareStack in Rack and Rails, respectively.

Usage

Building a middleware stack is very easy:

app = Middleware::Builder.new do |b|
  b.use A
  b.use B
end

# Call the middleware
app.call(7)

Instance Method Summary collapse

Constructor Details

#initialize(opts = nil) { ... } ⇒ Builder

Initializes the builder. An optional block can be passed which will either yield the builder or be evaluated in the context of the instance.

Example:

Builder.new do |b|
  b.use A
  b.use B
end

Builder.new do
  use A
  use B
end

Parameters:

  • opts (Hash) (defaults to: nil) —

    Options hash

Options Hash (opts):

  • :runner_class (Class) —

    The class to wrap the middleware stack in which knows how to run them.

Yields:

  • [] Evaluated in this instance which allows you to use methods like #use and such.



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 66

def initialize(opts = nil, &block)
  opts ||= {}
  @runner_class = opts.fetch(:runner_class, Runner)
  @middleware_name = opts.fetch(:name, 'Middleware')

  if block_given?
    if block.arity == 1
      yield self
    else
      instance_eval(&block)
    end
  end
end

Instance Method Details

#call(env = nil) ⇒ Object

Runs the builder stack with the given environment.



155
156
157
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 155

def call(env = nil)
  to_app.call(env)
end

#delete(index) ⇒ Object

Deletes the given middleware object or index



149
150
151
152
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 149

def delete(index)
  index = self.index(index) unless index.is_a?(Integer)
  stack.delete_at(index)
end

#flatten ⇒ Object

Returns a mergeable version of the builder. If use is called with the return value of this method, then the stack will merge, instead of being treated as a separate single middleware.



88
89
90
91
92
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 88

def flatten
  lambda do |env|
    call(env)
  end
end

#inject_logger(logger) ⇒ Object 



166
167
168
169
170
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 166

def inject_logger logger
  insert_before_each Middleware::Logger, logger, name

  self
end

#insert(index, middleware, *args, &block) ⇒ Object Also known as: insert_before

Inserts a middleware at the given index or directly before the given middleware object.



111
112
113
114
115
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 111

def insert(index, middleware, *args, &block)
  index = self.index(index) unless index.is_a?(Integer)
  fail "no such middleware to insert before: #{index.inspect}" unless index
  stack.insert(index, [middleware, args, block])
end

#insert_after(index, middleware, *args, &block) ⇒ Object

Inserts a middleware after the given index or middleware object.



120
121
122
123
124
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 120

def insert_after(index, middleware, *args, &block)
  index = self.index(index) unless index.is_a?(Integer)
  fail "no such middleware to insert after: #{index.inspect}" unless index
  insert(index + 1, middleware, *args, &block)
end

#insert_after_each(middleware, *args, &block) ⇒ Object

Inserts a middleware after each middleware object



134
135
136
137
138
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 134

def insert_after_each(middleware, *args, &block)
  self.stack = stack.reduce([]) do |carry, item|
    carry.push(item, [middleware, args, block])
  end
end

#insert_before_each(middleware, *args, &block) ⇒ Object

Inserts a middleware before each middleware object



127
128
129
130
131
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 127

def insert_before_each(middleware, *args, &block)
  self.stack = stack.reduce([]) do |carry, item|
    carry.push([middleware, args, block], item)
  end
end

#inspect ⇒ Object 



159
160
161
162
163
164
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 159

def inspect
  name+'[' + stack.map do |middleware|
    name = middleware[0].is_a?(Proc) ? 'Proc' : middleware[0].name
    "#{name}(#{middleware[1].join(', ')})"
  end.join(', ') + ']'
end

#name ⇒ Object

Returns the name of the current middleware



81
82
83
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 81

def name
  @middleware_name
end

#replace(index, middleware, *args, &block) ⇒ Object

Replaces the given middleware object or index with the new middleware.



141
142
143
144
145
146
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 141

def replace(index, middleware, *args, &block)
  index = self.index index unless index.is_a? Integer

  delete(index)
  insert(index, middleware, *args, &block)
end

#use(middleware, *args, &block) ⇒ Object

Adds a middleware class to the middleware stack. Any additional args and a block, if given, are saved and passed to the initializer of the middleware.

Parameters:

  • middleware (Class) —

    The middleware class



99
100
101
102
103
104
105
106
107
108
 
# File 'lib/convenient_service/dependencies/extractions/ruby_middleware/middleware/builder.rb', line 99

def use(middleware, *args, &block)
  if middleware.is_a?(Builder)
    # Merge in the other builder's stack into our own
    stack.concat(middleware.stack)
  else
    stack << [middleware, args, block]
  end

  self
end