More thread safety: Create new Executor instance for each stack start.

It in turn creates new instances of Middleware chain.

lib/modware/stack.rb

@@ -8,70 +8,81 @@ def initialize(env:)
                    when Class then env
                    else KeyStruct[*env]
                    end
-      @middlewares = []
+      @middleware_mods = []
     end
 
     def add(mod)
-      middleware = Middleware.new(self, mod)
-      @middlewares.last._next = middleware if @middlewares.any?
-      @middlewares << middleware
+      @middleware_mods << mod
     end
 
-    def start(*args, &implementation)
+    def start(*args, &base_implementation)
       env = @env_klass.new(*args)
-      execute_stack(env, implementation)
+      Executor.new(@middleware_mods).execute(env, base_implementation)
       env
     end
 
     private
 
-    def execute_stack(env, base_implementation)
-      return call_implementation(env, base_implementation) unless @middlewares.any?
-
-      @middlewares.each do |middleware|
-        middleware.before env if middleware.respond_to? :before
+    class Executor
+      def initialize(middleware_mods)
+        prev = nil
+        @middlewares = middleware_mods.map { |mod|
+          Middleware.new(self, mod).tap { |middleware|
+            prev._modware_next = middleware if prev
+            prev = middleware
+          }
+        }
       end
 
-      @middlewares.first._call(env, base_implementation)
+      def execute(env, base_implementation)
+        return call_implementation(env, base_implementation) if @middlewares.empty?
+
+        @middlewares.each do |middleware|
+          middleware.before env if middleware.respond_to? :before
+        end
+
+        @middlewares.first._modware_call(env, base_implementation)
 
-      @middlewares.each do |middleware|
-        middleware.after env if middleware.respond_to? :after
+        @middlewares.each do |middleware|
+          middleware.after env if middleware.respond_to? :after
+        end
       end
-    end
 
-    def call_implementation(env, base_implementation)
-      if middleware = @middlewares.select(&it.respond_to?(:implement)).last
-        middleware.implement(env)
-      elsif base_implementation
-        base_implementation.call env
-      else
-        raise StackError, "No base implementation nor middleware implementation in stack"
+      def call_implementation(env, base_implementation)
+        if middleware = @middlewares.select(&it.respond_to?(:implement)).last
+          middleware.implement(env)
+        elsif base_implementation
+          base_implementation.call env
+        else
+          raise StackError, "No base implementation nor middleware implementation in stack"
+        end
       end
     end
 
+
     class Middleware
-      attr_accessor :_next
+      attr_accessor :_modware_next
 
-      def initialize(stack, mod)
-        @stack = stack
+      def initialize(executor, mod)
+        @executor = executor
         singleton_class.send :include, mod
       end
 
-      def _call(env, base_implementation)
+      def _modware_call(env, base_implementation)
         if respond_to? :around
           around(env) { |env|
-            _continue env, base_implementation
+            _modware_continue env, base_implementation
           }
         else
-          _continue env, base_implementation
+          _modware_continue env, base_implementation
         end
       end
 
-      def _continue(env, base_implementation)
-        if self._next
-          self._next._call(env, base_implementation)
+      def _modware_continue(env, base_implementation)
+        if self._modware_next
+          self._modware_next._modware_call(env, base_implementation)
         else
-          @stack.send :call_implementation, env, base_implementation
+          @executor.call_implementation env, base_implementation
         end
       end
     end