Adds WrappingExecutor class

This can be used for wrapping args and task before passing it to
Executor.

Author: petrblaho

lib/concurrent/executor/wrapping_executor.rb

@@ -0,0 +1,33 @@
+module Concurrent
+
+  # Used for wrapping an Executor with Wrapper which can modify arguments or task passed to Executor
+  class WrappingExecutor < Synchronization::Object
+    safe_initialization!
+
+    include ExecutorService
+
+    # @param [Executor] executor Executor to be wrapped
+    # @yield [*args, &task] Wrapper block which wraps the task with args before it is passed to the Executor
+    # @yieldparam [Array<Object>] *args Wrapper block will get these from {WrappingExecutor#post} call
+    # @yieldparam [block] &task Wrapper block will get this from {WrappingExecutor#post} call
+    # @yieldreturn [Array<Object>] args and task on the last place.
+    def initialize(executor, &wrapper)
+      super()
+      @Wrapper  = wrapper
+      @Executor = executor
+    end
+
+    def post(*args, &task)
+      *args, task = @Wrapper.call(*args, &task)
+      @Executor.post(*args, &task)
+    end
+
+    def can_overflow?
+      @Executor.can_overflow?
+    end
+
+    def serialized?
+      @Executor.serialized?
+    end
+  end
+end

lib/concurrent/executors.rb

@@ -18,3 +18,4 @@
 require 'concurrent/executor/single_thread_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
+require 'concurrent/executor/wrapping_executor'

spec/concurrent/executor/wrapping_executor_spec.rb

@@ -0,0 +1,48 @@
+module Concurrent
+  RSpec.describe WrappingExecutor do
+
+    let(:wrapping_executor) { WrappingExecutor.new(executor, &wrapper) }
+    let(:executor) { Concurrent.global_fast_executor }
+    let(:wrapper) { nil }
+    let(:args) { { foo: 'bar', baz: 42 } }
+    let(:task) { -> (*args) { return nil } }
+
+    subject { wrapping_executor }
+
+    it { is_expected.to be_kind_of(WrappingExecutor) }
+    it { is_expected.to respond_to(:post) }
+    it { is_expected.to respond_to(:can_overflow?) }
+    it { is_expected.to respond_to(:serialized?) }
+
+    describe '#post' do
+      context 'with passthrough wrapper' do
+        let(:wrapper) { -> (*args, &task) { return *args, task } }
+
+        it {
+          expect(executor).to receive(:post).with(args) { |&block| expect(block).to be(task) }
+          wrapping_executor.post(args, &task)
+        }
+      end
+
+      context 'with wrapper modifying args' do
+        let(:wrapper) { -> (*args, &task) { return *args, { xyz: 'abc' }, task } }
+
+        it {
+          expect(executor).to receive(:post).with(args, { xyz: 'abc' }) { |&block| expect(block).to be(task) }
+          wrapping_executor.post(args, &task)
+        }
+      end
+
+      context 'with wrapper modifying task' do
+        let(:wrapper) { -> (*args, &task) { return *args, another_task } }
+        let(:another_task) { -> (*args) { return true } }
+
+        it {
+          expect(executor).to receive(:post).with(args) { |&block| expect(block).to be(another_task) }
+          wrapping_executor.post(args, &task)
+        }
+      end
+
+    end
+  end
+end